[WIP][libc++][format] DO NOT REVIEW

[Mordante]

Summary

Contains a new approach of std::format's parser and formatters. This
approach saves over 10KB of the binary size.

This patch is still work-in-progress. This review is to test the CI.

[Mordante]

Trigger CI.

[Mordante]

Fixes linting issues.

[Mordante]

Clang-tidy fixes.

[Mordante]

More CI fixes.

[Mordante]

Attempt to fix several CI issues.

[Mordante]

Add some debug information.

[Mordante]

More CI fixes.

[Mordante]

Attempt more CI fixes.

[Mordante]

Fixes copy-paste error.

[Mordante]

Refactor and polish.

[Mordante]

Fix CI error.

[Mordante]

The changes in this review have been implemented in smaller patches.

libcxx/benchmarks/std_format_spec_string_unicode.bench.cpp

for (int i = 0; i < 100; ++i)
       it = std::copy_n(input, size_, it);
   }
 
   constexpr size_t size() const noexcept { return data_.size(); }
   constexpr const CharT* begin() const noexcept { return data_.begin(); }
   constexpr const CharT* end() const noexcept { return data_.end(); }
 
   void test(benchmark::State& state) const {
+    std::basic_string_view<CharT> sv{data_.begin(), data_.end()};
     for (auto _ : state)
-      benchmark::DoNotOptimize(std::__format_spec::__get_string_alignment(
-          begin(), end(), 1'000'000, 1'000'000));
+      if constexpr (std::same_as<CharT, char>)
+        benchmark::DoNotOptimize(std::formatted_size("{:{}.{}}", sv, 1'000'000, 1'000'000));
+      else
+        benchmark::DoNotOptimize(std::formatted_size(L"{:{}.{}}", sv, 1'000'000, 1'000'000));
+
     state.SetItemsProcessed(state.iterations() * size());
   }
 };
 
-#define TEST(u8)                                                               \
-  if constexpr (std::same_as<CharT, char>) {                                   \
-    constexpr auto p = tester{u8};                                             \
-    p.test(state);                                                             \
-  } else if constexpr (std::same_as<CharT, char16_t>) {                        \
-    constexpr auto p = tester{TEST_CONCAT(u, u8)};                             \
-    p.test(state);                                                             \
-  } else {                                                                     \
-    constexpr auto p = tester{TEST_CONCAT(U, u8)};                             \
-    p.test(state);                                                             \
+#  define TEST(u8)                                                                                                     \
+    if constexpr (std::same_as<CharT, char>) {                                                                         \
+      constexpr auto p = tester{u8};                                                                                   \
+      p.test(state);                                                                                                   \
+    } else {                                                                                                           \
+      constexpr auto p = tester{TEST_CONCAT(L, u8)};                                                                   \
+      p.test(state);                                                                                                   \
     }
 
 template <class CharT>
 static void BM_EstimateLengthNoMultiByte(benchmark::State& state) {
   TEST("The quick brown fox jumps over the lazy dog");
 }
 
 template <class CharT>
 static void BM_EstimateLengthTwoByteDE(benchmark::State& state) {

 BENCHMARK_TEMPLATE(BM_EstimateLengthThreeByteSingleColumnLow, char);
 BENCHMARK_TEMPLATE(BM_EstimateLengthThreeByteSingleColumnHigh, char);
 BENCHMARK_TEMPLATE(BM_EstimateLengthThreeByteDoubleColumn, char);
 BENCHMARK_TEMPLATE(BM_EstimateLengthThreeByte, char);
 BENCHMARK_TEMPLATE(BM_EstimateLengthFourByteSingleColumn, char);
 BENCHMARK_TEMPLATE(BM_EstimateLengthFourByteDoubleColumn, char);
 BENCHMARK_TEMPLATE(BM_EstimateLengthFourByte, char);
 
-BENCHMARK_TEMPLATE(BM_EstimateLengthNoMultiByte, char16_t);
-BENCHMARK_TEMPLATE(BM_EstimateLengthTwoByteDE, char16_t);
-BENCHMARK_TEMPLATE(BM_EstimateLengthTwoBytePL, char16_t);
-BENCHMARK_TEMPLATE(BM_EstimateLengthThreeByteSingleColumnLow, char16_t);
-BENCHMARK_TEMPLATE(BM_EstimateLengthThreeByteSingleColumnHigh, char16_t);
-BENCHMARK_TEMPLATE(BM_EstimateLengthThreeByteDoubleColumn, char16_t);
-BENCHMARK_TEMPLATE(BM_EstimateLengthThreeByte, char16_t);
-BENCHMARK_TEMPLATE(BM_EstimateLengthFourByteSingleColumn, char16_t);
-BENCHMARK_TEMPLATE(BM_EstimateLengthFourByteDoubleColumn, char16_t);
-BENCHMARK_TEMPLATE(BM_EstimateLengthFourByte, char16_t);
-
-BENCHMARK_TEMPLATE(BM_EstimateLengthNoMultiByte, char32_t);
-BENCHMARK_TEMPLATE(BM_EstimateLengthTwoByteDE, char32_t);
-BENCHMARK_TEMPLATE(BM_EstimateLengthTwoBytePL, char32_t);
-BENCHMARK_TEMPLATE(BM_EstimateLengthThreeByteSingleColumnLow, char32_t);
-BENCHMARK_TEMPLATE(BM_EstimateLengthThreeByteSingleColumnHigh, char32_t);
-BENCHMARK_TEMPLATE(BM_EstimateLengthThreeByteDoubleColumn, char32_t);
-BENCHMARK_TEMPLATE(BM_EstimateLengthThreeByte, char32_t);
-BENCHMARK_TEMPLATE(BM_EstimateLengthFourByteSingleColumn, char32_t);
-BENCHMARK_TEMPLATE(BM_EstimateLengthFourByteDoubleColumn, char32_t);
-BENCHMARK_TEMPLATE(BM_EstimateLengthFourByte, char32_t);
+BENCHMARK_TEMPLATE(BM_EstimateLengthNoMultiByte, wchar_t);
+BENCHMARK_TEMPLATE(BM_EstimateLengthTwoByteDE, wchar_t);
+BENCHMARK_TEMPLATE(BM_EstimateLengthTwoBytePL, wchar_t);
+BENCHMARK_TEMPLATE(BM_EstimateLengthThreeByteSingleColumnLow, wchar_t);
+BENCHMARK_TEMPLATE(BM_EstimateLengthThreeByteSingleColumnHigh, wchar_t);
+BENCHMARK_TEMPLATE(BM_EstimateLengthThreeByteDoubleColumn, wchar_t);
+BENCHMARK_TEMPLATE(BM_EstimateLengthThreeByte, wchar_t);
+BENCHMARK_TEMPLATE(BM_EstimateLengthFourByteSingleColumn, wchar_t);
+BENCHMARK_TEMPLATE(BM_EstimateLengthFourByteDoubleColumn, wchar_t);
+BENCHMARK_TEMPLATE(BM_EstimateLengthFourByte, wchar_t);
 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
 
   benchmark::RunSpecifiedBenchmarks();
 }
 #else
 int main(int, char**) { return 0; }
 #endif

libcxx/include/CMakeLists.txt

set(files
   __format/format_string.h
   __format/format_to_n_result.h
   __format/formatter.h
   __format/formatter_bool.h
   __format/formatter_char.h
   __format/formatter_floating_point.h
   __format/formatter_integer.h
   __format/formatter_integral.h
+  __format/formatter_output.h
   __format/formatter_pointer.h
   __format/formatter_string.h
   __format/parser_std_format_spec.h
   __functional/binary_function.h
   __functional/binary_negate.h
   __functional/bind.h
   __functional/bind_back.h
   __functional/bind_front.h

libcxx/include/__format/buffer.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_BUFFER_H
 #define _LIBCPP___FORMAT_BUFFER_H
 
 #include <__algorithm/copy_n.h>
 #include <__algorithm/unwrap_iter.h>
 #include <__config>
 #include <__format/enable_insertable.h>
-#include <__format/formatter.h> // for __char_type TODO FMT Move the concept?
+#include <__format/format_fwd.h> // for __char_type TODO FMT Move the concept?
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/wrap_iter.h>
 #include <__utility/move.h>
 #include <concepts>
 #include <cstddef>
 #include <type_traits>

libcxx/include/__format/format_context.h

 #ifndef _LIBCPP___FORMAT_FORMAT_CONTEXT_H
 #define _LIBCPP___FORMAT_FORMAT_CONTEXT_H
 
 #include <__availability>
 #include <__config>
 #include <__format/buffer.h>
 #include <__format/format_args.h>
 #include <__format/format_fwd.h>
+#include <__format/formatter.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/concepts.h>
 #include <concepts>
 
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
 #include <locale>
 #include <optional>
 #endif

libcxx/include/__format/format_fwd.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_FORMAT_FWD_H
 #define _LIBCPP___FORMAT_FORMAT_FWD_H
 
 #include <__availability>
+#include <__concepts/same_as.h>
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
 template <class _Context>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT basic_format_arg;
 
 template <class _Context, class... _Args>
 struct _LIBCPP_TEMPLATE_VIS __format_arg_store;
 
-template <class _Tp, class _CharT = char>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter;
+namespace __formatter {
+
+/** The character types that formatters are specialized for. */
+template <class _CharT>
+concept __char_type = same_as<_CharT, char> || same_as<_CharT, wchar_t>;
+
+} // namespace __formatter
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_FORMAT_FWD_H

libcxx/include/__format/formatter.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_H
 #define _LIBCPP___FORMAT_FORMATTER_H
 
-#include <__algorithm/copy.h>
-#include <__algorithm/fill_n.h>
-#include <__algorithm/transform.h>
-#include <__assert>
 #include <__availability>
 #include <__config>
-#include <__format/format_error.h>
-#include <__format/format_fwd.h>
-#include <__format/format_string.h>
-#include <__format/parser_std_format_spec.h>
-#include <__utility/move.h>
-#include <__utility/unreachable.h>
-#include <string_view>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
+template <class _Tp, class _CharT = char>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter;
+
 /// The default formatter template.
 ///
 /// [format.formatter.spec]/5
 /// If F is a disabled specialization of formatter, these values are false:
 /// - is_default_constructible_v<F>,
 /// - is_copy_constructible_v<F>,
 /// - is_move_constructible_v<F>,
 /// - is_copy_assignable<F>, and
 /// - is_move_assignable<F>.
 template <class _Tp, class _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter {
   formatter() = delete;
   formatter(const formatter&) = delete;
   formatter& operator=(const formatter&) = delete;
 };
 
-namespace __format_spec {
-
-_LIBCPP_HIDE_FROM_ABI inline char* __insert_sign(char* __buf, bool __negative,
-                                                 _Flags::_Sign __sign) {
-  if (__negative)
-    *__buf++ = '-';
-  else
-    switch (__sign) {
-    case _Flags::_Sign::__default:
-    case _Flags::_Sign::__minus:
-      // No sign added.
-      break;
-    case _Flags::_Sign::__plus:
-      *__buf++ = '+';
-      break;
-    case _Flags::_Sign::__space:
-      *__buf++ = ' ';
-      break;
-    }
-
-  return __buf;
-}
-
-_LIBCPP_HIDE_FROM_ABI constexpr char __hex_to_upper(char c) {
-  switch (c) {
-  case 'a':
-    return 'A';
-  case 'b':
-    return 'B';
-  case 'c':
-    return 'C';
-  case 'd':
-    return 'D';
-  case 'e':
-    return 'E';
-  case 'f':
-    return 'F';
-  }
-  return c;
-}
-
-} // namespace __format_spec
-
-namespace __formatter {
-
-/** The character types that formatters are specialized for. */
-template <class _CharT>
-concept __char_type = same_as<_CharT, char> || same_as<_CharT, wchar_t>;
-
-struct _LIBCPP_TEMPLATE_VIS __padding_size_result {
-  size_t __before;
-  size_t __after;
-};
-
-_LIBCPP_HIDE_FROM_ABI constexpr __padding_size_result
-__padding_size(size_t __size, size_t __width,
-               __format_spec::_Flags::_Alignment __align) {
-  _LIBCPP_ASSERT(__width > __size,
-                 "Don't call this function when no padding is required");
-  _LIBCPP_ASSERT(
-      __align != __format_spec::_Flags::_Alignment::__default,
-      "Caller should adjust the default to the value required by the type");
-
-  size_t __fill = __width - __size;
-  switch (__align) {
-  case __format_spec::_Flags::_Alignment::__default:
-    __libcpp_unreachable();
-
-  case __format_spec::_Flags::_Alignment::__left:
-    return {0, __fill};
-
-  case __format_spec::_Flags::_Alignment::__center: {
-    // The extra padding is divided per [format.string.std]/3
-    // __before = floor(__fill, 2);
-    // __after = ceil(__fill, 2);
-    size_t __before = __fill / 2;
-    size_t __after = __fill - __before;
-    return {__before, __after};
-  }
-  case __format_spec::_Flags::_Alignment::__right:
-    return {__fill, 0};
-  }
-  __libcpp_unreachable();
-}
-
-/**
- * Writes the input to the output with the required padding.
- *
- * Since the output column width is specified the function can be used for
- * ASCII and Unicode input.
- *
- * @pre [@a __first, @a __last) is a valid range.
- * @pre @a __size <= @a __width. Using this function when this pre-condition
- *      doesn't hold incurs an unwanted overhead.
- *
- * @param __out_it    The output iterator to write to.
- * @param __first     Pointer to the first element to write.
- * @param __last      Pointer beyond the last element to write.
- * @param __size      The (estimated) output column width. When the elements
- *                    to be written are ASCII the following condition holds
- *                    @a __size == @a __last - @a __first.
- * @param __width     The number of output columns to write.
- * @param __fill      The character used for the alignment of the output.
- *                    TODO FMT Will probably change to support Unicode grapheme
- *                    cluster.
- * @param __alignment The requested alignment.
- *
- * @returns           An iterator pointing beyond the last element written.
- *
- * @note The type of the elements in range [@a __first, @a __last) can differ
- * from the type of @a __fill. Integer output uses @c std::to_chars for its
- * conversion, which means the [@a __first, @a __last) always contains elements
- * of the type @c char.
- */
-template <class _CharT, class _Fill>
-_LIBCPP_HIDE_FROM_ABI auto
-__write(output_iterator<const _CharT&> auto __out_it, const _CharT* __first,
-        const _CharT* __last, size_t __size, size_t __width, _Fill __fill,
-        __format_spec::_Flags::_Alignment __alignment) -> decltype(__out_it) {
-
-  _LIBCPP_ASSERT(__first <= __last, "Not a valid range");
-  _LIBCPP_ASSERT(__size < __width, "Precondition failure");
-
-  __padding_size_result __padding =
-      __padding_size(__size, __width, __alignment);
-  __out_it = _VSTD::fill_n(_VSTD::move(__out_it), __padding.__before, __fill);
-  __out_it = _VSTD::copy(__first, __last, _VSTD::move(__out_it));
-  return _VSTD::fill_n(_VSTD::move(__out_it), __padding.__after, __fill);
-}
-
-/**
- * @overload
- *
- * Writes additional zero's for the precision before the exponent.
- * This is used when the precision requested in the format string is larger
- * than the maximum precision of the floating-point type. These precision
- * digits are always 0.
- *
- * @param __exponent           The location of the exponent character.
- * @param __num_trailing_zeros The number of 0's to write before the exponent
- *                             character.
- */
-template <class _CharT, class _Fill>
-_LIBCPP_HIDE_FROM_ABI auto __write(output_iterator<const _CharT&> auto __out_it, const _CharT* __first,
-                                   const _CharT* __last, size_t __size, size_t __width, _Fill __fill,
-                                   __format_spec::_Flags::_Alignment __alignment, const _CharT* __exponent,
-                                   size_t __num_trailing_zeros) -> decltype(__out_it) {
-  _LIBCPP_ASSERT(__first <= __last, "Not a valid range");
-  _LIBCPP_ASSERT(__num_trailing_zeros > 0, "The overload not writing trailing zeros should have been used");
-
-  __padding_size_result __padding = __padding_size(__size + __num_trailing_zeros, __width, __alignment);
-  __out_it = _VSTD::fill_n(_VSTD::move(__out_it), __padding.__before, __fill);
-  __out_it = _VSTD::copy(__first, __exponent, _VSTD::move(__out_it));
-  __out_it = _VSTD::fill_n(_VSTD::move(__out_it), __num_trailing_zeros, _CharT('0'));
-  __out_it = _VSTD::copy(__exponent, __last, _VSTD::move(__out_it));
-  return _VSTD::fill_n(_VSTD::move(__out_it), __padding.__after, __fill);
-}
-
-/**
- * @overload
- *
- * Uses a transformation operation before writing an element.
- *
- * TODO FMT Fill will probably change to support Unicode grapheme cluster.
- */
-template <class _CharT, class _UnaryOperation, class _Fill>
-_LIBCPP_HIDE_FROM_ABI auto
-__write(output_iterator<const _CharT&> auto __out_it, const _CharT* __first,
-        const _CharT* __last, size_t __size, _UnaryOperation __op,
-        size_t __width, _Fill __fill,
-        __format_spec::_Flags::_Alignment __alignment) -> decltype(__out_it) {
-
-  _LIBCPP_ASSERT(__first <= __last, "Not a valid range");
-  _LIBCPP_ASSERT(__size < __width, "Precondition failure");
-
-  __padding_size_result __padding =
-      __padding_size(__size, __width, __alignment);
-  __out_it = _VSTD::fill_n(_VSTD::move(__out_it), __padding.__before, __fill);
-  __out_it = _VSTD::transform(__first, __last, _VSTD::move(__out_it), __op);
-  return _VSTD::fill_n(_VSTD::move(__out_it), __padding.__after, __fill);
-}
-
-/**
- * Writes Unicode input to the output with the required padding.
- *
- * This function does almost the same as the @ref __write function, but handles
- * the width estimation of the Unicode input.
- *
- * @param __str       The range [@a __first, @a __last).
- * @param __precision The width to truncate the input string to, use @c -1 for
- *                     no limit.
- */
-template <class _CharT, class _Fill>
-_LIBCPP_HIDE_FROM_ABI auto
-__write_unicode(output_iterator<const _CharT&> auto __out_it,
-                basic_string_view<_CharT> __str, ptrdiff_t __width,
-                ptrdiff_t __precision, _Fill __fill,
-                __format_spec::_Flags::_Alignment __alignment)
-    -> decltype(__out_it) {
-
-  // This value changes when there Unicode column width limits the output
-  // size.
-  auto __last = __str.end();
-  if (__width != 0 || __precision != -1) {
-    __format_spec::__string_alignment<_CharT> __format_traits =
-        __format_spec::__get_string_alignment(__str.begin(), __str.end(),
-                                              __width, __precision);
-
-    if (__format_traits.__align)
-      return __write(_VSTD::move(__out_it), __str.begin(),
-                     __format_traits.__last, __format_traits.__size, __width,
-                     __fill, __alignment);
-
-    // No alignment required update the output based on the precision.
-    // This might be the same as __str.end().
-    __last = __format_traits.__last;
-  }
-
-  // Copy the input to the output. The output size might be limited by the
-  // precision.
-  return _VSTD::copy(__str.begin(), __last, _VSTD::move(__out_it));
-}
-
-} // namespace __formatter
-
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_FORMATTER_H
+

libcxx/include/__format/formatter_bool.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_BOOL_H
 #define _LIBCPP___FORMAT_FORMATTER_BOOL_H
 
+#include <__assert>
 #include <__availability>
 #include <__config>
-#include <__format/format_error.h>
 #include <__format/format_fwd.h>
+#include <__format/format_parse_context.h>
 #include <__format/formatter.h>
 #include <__format/formatter_integral.h>
+#include <__format/formatter_output.h>
 #include <__format/parser_std_format_spec.h>
-#include <string_view>
-
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
-#include <locale>
-#endif
+#include <__utility/unreachable.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
-namespace __format_spec {
-
-template <class _CharT>
-class _LIBCPP_TEMPLATE_VIS __parser_bool : public __parser_integral<_CharT> {
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<bool, _CharT> {
 public:
-  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(auto& __parse_ctx)
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
       -> decltype(__parse_ctx.begin()) {
-    auto __it = __parser_integral<_CharT>::__parse(__parse_ctx);
+    auto __result = __parser_.__parse(__parse_ctx, __format_spec::__fields_integral);
+    __format_spec::__process_parsed_bool(__parser_);
+    return __result;
+  }
 
-    switch (this->__type) {
-    case _Flags::_Type::__default:
-      this->__type = _Flags::_Type::__string;
-      [[fallthrough]];
-    case _Flags::_Type::__string:
-      this->__handle_bool();
-      break;
-
-    case _Flags::_Type::__binary_lower_case:
-    case _Flags::_Type::__binary_upper_case:
-    case _Flags::_Type::__octal:
-    case _Flags::_Type::__decimal:
-    case _Flags::_Type::__hexadecimal_lower_case:
-    case _Flags::_Type::__hexadecimal_upper_case:
-      this->__handle_integer();
-      break;
+  _LIBCPP_HIDE_FROM_ABI auto format(bool __value, auto& __ctx) const -> decltype(__ctx.out()) {
+    switch (__parser_.__type_) {
+    case __format_spec::__type::__string:
+      return __formatter::__format_bool(__value, __ctx, __parser_.__resolve_dynamic_sizes(__ctx));
+
+    case __format_spec::__type::__binary_lower_case:
+    case __format_spec::__type::__binary_upper_case:
+    case __format_spec::__type::__octal:
+    case __format_spec::__type::__decimal:
+    case __format_spec::__type::__hexadecimal_lower_case:
+    case __format_spec::__type::__hexadecimal_upper_case:
+      // Casting this to a formatter more likely being used reduces the binary size.
+      return __formatter::__format_integer(static_cast<unsigned >(__value), __ctx,
+                                           __parser_.__resolve_dynamic_sizes(__ctx));
 
     default:
-      __throw_format_error(
-          "The format-spec type has a type not supported for a bool argument");
+      _LIBCPP_ASSERT(false, "The parse function should have validated the type");
+      __libcpp_unreachable();
     }
-
-    return __it;
   }
-};
-
-template <class _CharT>
-struct _LIBCPP_TEMPLATE_VIS __bool_strings;
 
-template <>
-struct _LIBCPP_TEMPLATE_VIS __bool_strings<char> {
-  static constexpr string_view __true{"true"};
-  static constexpr string_view __false{"false"};
-};
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-template <>
-struct _LIBCPP_TEMPLATE_VIS __bool_strings<wchar_t> {
-  static constexpr wstring_view __true{L"true"};
-  static constexpr wstring_view __false{L"false"};
-};
-#endif
-
-template <class _CharT>
-using __formatter_bool = __formatter_integral<__parser_bool<_CharT>>;
-
-} //namespace __format_spec
-
-// [format.formatter.spec]/2.3
-// For each charT, for each cv-unqualified arithmetic type ArithmeticT other
-// than char, wchar_t, char8_t, char16_t, or char32_t, a specialization
-
-template <__formatter::__char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<bool, _CharT>
-    : public __format_spec::__formatter_bool<_CharT> {
-  using _Base = __format_spec::__formatter_bool<_CharT>;
-
-  _LIBCPP_HIDE_FROM_ABI auto format(bool __value, auto& __ctx)
-      -> decltype(__ctx.out()) {
-    if (this->__type != __format_spec::_Flags::_Type::__string)
-      return _Base::format(static_cast<unsigned char>(__value), __ctx);
-
-    if (this->__width_needs_substitution())
-      this->__substitute_width_arg_id(__ctx.arg(this->__width));
-
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
-    if (this->__locale_specific_form) {
-      const auto& __np = use_facet<numpunct<_CharT>>(__ctx.locale());
-      basic_string<_CharT> __str = __value ? __np.truename() : __np.falsename();
-      return __formatter::__write_unicode(
-          __ctx.out(), basic_string_view<_CharT>{__str}, this->__width, -1,
-          this->__fill, this->__alignment);
-    }
-#endif
-    basic_string_view<_CharT> __str =
-        __value ? __format_spec::__bool_strings<_CharT>::__true
-                : __format_spec::__bool_strings<_CharT>::__false;
-
-    // The output only uses ASCII so every character is one column.
-    unsigned __size = __str.size();
-    if (__size >= this->__width)
-      return _VSTD::copy(__str.begin(), __str.end(), __ctx.out());
-
-    return __formatter::__write(__ctx.out(), __str.begin(), __str.end(), __size,
-                                this->__width, this->__fill, this->__alignment);
-  }
+  __format_spec::__parser<_CharT> __parser_;
 };
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_FORMATTER_BOOL_H

libcxx/include/__format/formatter_char.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_CHAR_H
 #define _LIBCPP___FORMAT_FORMATTER_CHAR_H
 
 #include <__availability>
+#include <__concepts/same_as.h>
 #include <__config>
-#include <__format/format_error.h>
 #include <__format/format_fwd.h>
+#include <__format/format_parse_context.h>
 #include <__format/formatter.h>
 #include <__format/formatter_integral.h>
+#include <__format/formatter_output.h>
 #include <__format/parser_std_format_spec.h>
+#include <type_traits> // is_signed_v
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
-namespace __format_spec {
-
-template <class _CharT>
-class _LIBCPP_TEMPLATE_VIS __parser_char : public __parser_integral<_CharT> {
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __formatter_char {
 public:
-  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(auto& __parse_ctx)
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
       -> decltype(__parse_ctx.begin()) {
-    auto __it = __parser_integral<_CharT>::__parse(__parse_ctx);
-
-    switch (this->__type) {
-    case _Flags::_Type::__default:
-      this->__type = _Flags::_Type::__char;
-      [[fallthrough]];
-    case _Flags::_Type::__char:
-      this->__handle_char();
-      break;
-
-    case _Flags::_Type::__binary_lower_case:
-    case _Flags::_Type::__binary_upper_case:
-    case _Flags::_Type::__octal:
-    case _Flags::_Type::__decimal:
-    case _Flags::_Type::__hexadecimal_lower_case:
-    case _Flags::_Type::__hexadecimal_upper_case:
-      this->__handle_integer();
-      break;
-
-    default:
-      __throw_format_error(
-          "The format-spec type has a type not supported for a char argument");
-    }
+    auto __result = __parser_.__parse(__parse_ctx, __format_spec::__fields_integral);
+    __format_spec::__process_parsed_char(__parser_);
+    return __result;
 
-    return __it;
+  _LIBCPP_HIDE_FROM_ABI auto format(_CharT __value, auto& __ctx) const -> decltype(__ctx.out()) {
+    if (__parser_.__type_ == __format_spec::__type::__char)
+      return __formatter::__format_char(__value, __ctx.out(), __parser_.__resolve_dynamic_sizes(__ctx));
+
+    if constexpr (sizeof(_CharT) <= sizeof(int)) {
+      // Promotes _CharT to an integral type. This reduces the number of
+      // instantiations of __format_integer reducing code size.
+      if constexpr (is_signed_v<_CharT>)
+        return __formatter::__format_integer(static_cast<int>(__value), __ctx,
+                                             __parser_.__resolve_dynamic_sizes(__ctx));
+      else
+        return __formatter::__format_integer(static_cast<unsigned>(__value), __ctx,
+                                             __parser_.__resolve_dynamic_sizes(__ctx));
+    } else
+      return __formatter::__format_integer(__value, __ctx, __parser_.__resolve_dynamic_sizes(__ctx));
   }
-};
 
-template <class _CharT>
-using __formatter_char = __formatter_integral<__parser_char<_CharT>>;
-
-} // namespace __format_spec
+  _LIBCPP_HIDE_FROM_ABI auto format(char __value, auto& __ctx) const -> decltype(__ctx.out())
+    requires(same_as<_CharT, wchar_t>)
+  {
+    return format(static_cast<wchar_t>(__value), __ctx);
+  }
 
-// [format.formatter.spec]/2.1 The specializations
+  __format_spec::__parser<_CharT> __parser_;
+};
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<char, char>
-    : public __format_spec::__formatter_char<char> {};
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<char, char> : public __formatter_char<char> {};
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#    ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<char, wchar_t>
-    : public __format_spec::__formatter_char<wchar_t> {
-  using _Base = __format_spec::__formatter_char<wchar_t>;
-
-  _LIBCPP_HIDE_FROM_ABI auto format(char __value, auto& __ctx)
-      -> decltype(__ctx.out()) {
-    return _Base::format(static_cast<wchar_t>(__value), __ctx);
-  }
-};
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<char, wchar_t> : public __formatter_char<wchar_t> {};
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
-    formatter<wchar_t, wchar_t>
-    : public __format_spec::__formatter_char<wchar_t> {};
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<wchar_t, wchar_t> : public __formatter_char<wchar_t> {
+};
+
+#    endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
+
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_FORMATTER_CHAR_H

libcxx/include/__format/formatter_floating_point.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_FLOATING_POINT_H
 #define _LIBCPP___FORMAT_FORMATTER_FLOATING_POINT_H
 
-#include <__algorithm/copy.h>
-#include <__algorithm/copy_n.h>
-#include <__algorithm/fill_n.h>
 #include <__algorithm/find.h>
 #include <__algorithm/min.h>
 #include <__algorithm/rotate.h>
 #include <__algorithm/transform.h>
-#include <__assert>
-#include <__concepts/arithmetic.h>
 #include <__config>
-#include <__format/format_error.h>
 #include <__format/format_fwd.h>
-#include <__format/format_string.h>
+#include <__format/format_parse_context.h>
 #include <__format/formatter.h>
 #include <__format/formatter_integral.h>
+#include <__format/formatter_output.h>
 #include <__format/parser_std_format_spec.h>
-#include <__utility/move.h>
+#include <__memory/allocator.h>
 #include <__utility/unreachable.h>
 #include <charconv>
-#include <cmath>
 
 #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
 
-namespace __format_spec {
+namespace __formatter {
 
 template <floating_point _Tp>
 _LIBCPP_HIDE_FROM_ABI char* __to_buffer(char* __first, char* __last, _Tp __value) {
   to_chars_result __r = _VSTD::to_chars(__first, __last, __value);
   _LIBCPP_ASSERT(__r.ec == errc(0), "Internal buffer too small");
   return __r.ptr;
 }
 
explicit _LIBCPP_HIDE_FROM_ABI __float_buffer(int __precision)
     //   - wchar_t: same argument as char, but additional std::copy won't work.
     //     The input is always a char buffer, so every char in the buffer needs
     //     to be converted from a char to a wchar_t.
     if (__precision_ > _Traits::__max_fractional) {
       __num_trailing_zeros_ = __precision_ - _Traits::__max_fractional;
       __precision_ = _Traits::__max_fractional;
     }
 
-    __size_ = __format_spec::__float_buffer_size<_Fp>(__precision_);
+    __size_ = __formatter::__float_buffer_size<_Fp>(__precision_);
     if (__size_ > _Traits::__stack_buffer_size)
       // The allocated buffer's contents don't need initialization.
       __begin_ = allocator<char>{}.allocate(__size_);
     else
       __begin_ = __buffer_;
   }
 
   _LIBCPP_HIDE_FROM_ABI ~__float_buffer() {
constexpr inline _LIBCPP_HIDE_FROM_ABI char* __find_exponent(char* __first, char* __last) {
   return __last;
 }
 
 template <class _Fp, class _Tp>
 _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_default(const __float_buffer<_Fp>& __buffer, _Tp __value,
                                                              char* __integral) {
   __float_result __result;
   __result.__integral = __integral;
-  __result.__last = __format_spec::__to_buffer(__integral, __buffer.end(), __value);
+  __result.__last = __formatter::__to_buffer(__integral, __buffer.end(), __value);
 
-  __result.__exponent = __format_spec::__find_exponent(__result.__integral, __result.__last);
+  __result.__exponent = __formatter::__find_exponent(__result.__integral, __result.__last);
 
   // Constrains:
   // - There's at least one decimal digit before the radix point.
   // - The radix point, when present, is placed before the exponent.
   __result.__radix_point = _VSTD::find(__result.__integral + 1, __result.__exponent, '.');
 
   // When the radix point isn't found its position is the exponent instead of
   // __result.__last.

 
 template <class _Fp, class _Tp>
 _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_hexadecimal_lower_case(const __float_buffer<_Fp>& __buffer,
                                                                             _Tp __value, int __precision,
                                                                             char* __integral) {
   __float_result __result;
   __result.__integral = __integral;
   if (__precision == -1)
-    __result.__last = __format_spec::__to_buffer(__integral, __buffer.end(), __value, chars_format::hex);
+    __result.__last = __formatter::__to_buffer(__integral, __buffer.end(), __value, chars_format::hex);
   else
-    __result.__last = __format_spec::__to_buffer(__integral, __buffer.end(), __value, chars_format::hex, __precision);
+    __result.__last = __formatter::__to_buffer(__integral, __buffer.end(), __value, chars_format::hex, __precision);
 
   // H = one or more hex-digits
   // S = sign
   // D = one or more decimal-digits
   // When the fractional part is zero and no precision the output is 0p+0
   // else the output is                                              0.HpSD
   // So testing the second position can differentiate between these two cases.
   char* __first = __integral + 1;
_LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_hexadecimal_lower_case(const __float_buffer<_Fp>& __buffer,
   return __result;
 }
 
 template <class _Fp, class _Tp>
 _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_hexadecimal_upper_case(const __float_buffer<_Fp>& __buffer,
                                                                             _Tp __value, int __precision,
                                                                             char* __integral) {
   __float_result __result =
-      __format_spec::__format_buffer_hexadecimal_lower_case(__buffer, __value, __precision, __integral);
+      __formatter::__format_buffer_hexadecimal_lower_case(__buffer, __value, __precision, __integral);
   _VSTD::transform(__result.__integral, __result.__exponent, __result.__integral, __hex_to_upper);
   *__result.__exponent = 'P';
   return __result;
 }
 
 template <class _Fp, class _Tp>
 _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_scientific_lower_case(const __float_buffer<_Fp>& __buffer,
                                                                            _Tp __value, int __precision,
                                                                            char* __integral) {
   __float_result __result;
   __result.__integral = __integral;
   __result.__last =
-      __format_spec::__to_buffer(__integral, __buffer.end(), __value, chars_format::scientific, __precision);
+      __formatter::__to_buffer(__integral, __buffer.end(), __value, chars_format::scientific, __precision);
 
   char* __first = __integral + 1;
   _LIBCPP_ASSERT(__first != __result.__last, "No exponent present");
   if (*__first == '.') {
     __result.__radix_point = __first;
-    __result.__exponent = __format_spec::__find_exponent(__first + 1, __result.__last);
+    __result.__exponent = __formatter::__find_exponent(__first + 1, __result.__last);
   } else {
     __result.__radix_point = __result.__last;
     __result.__exponent = __first;
   }
 
   // clang-format off
   _LIBCPP_ASSERT((__result.__integral != __result.__last) &&
                  (__result.__radix_point == __result.__last || *__result.__radix_point == '.') &&
                  (__result.__exponent != __result.__last && *__result.__exponent == 'e'),
                  "Post-condition failure.");
   // clang-format on
   return __result;
 }
 
 template <class _Fp, class _Tp>
 _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_scientific_upper_case(const __float_buffer<_Fp>& __buffer,
                                                                            _Tp __value, int __precision,
                                                                            char* __integral) {
   __float_result __result =
-      __format_spec::__format_buffer_scientific_lower_case(__buffer, __value, __precision, __integral);
+      __formatter::__format_buffer_scientific_lower_case(__buffer, __value, __precision, __integral);
   *__result.__exponent = 'E';
   return __result;
 }
 
 template <class _Fp, class _Tp>
 _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_fixed(const __float_buffer<_Fp>& __buffer, _Tp __value,
                                                            int __precision, char* __integral) {
   __float_result __result;
   __result.__integral = __integral;
-  __result.__last = __format_spec::__to_buffer(__integral, __buffer.end(), __value, chars_format::fixed, __precision);
+  __result.__last = __formatter::__to_buffer(__integral, __buffer.end(), __value, chars_format::fixed, __precision);
 
   // When there's no precision there's no radix point.
   // Else the radix point is placed at __precision + 1 from the end.
   // By converting __precision to a bool the subtraction can be done
   // unconditionally.
   __result.__radix_point = __result.__last - (__precision + bool(__precision));
   __result.__exponent = __result.__last;
 

 template <class _Fp, class _Tp>
 _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_general_lower_case(__float_buffer<_Fp>& __buffer, _Tp __value,
                                                                         int __precision, char* __integral) {
 
   __buffer.__remove_trailing_zeros();
 
   __float_result __result;
   __result.__integral = __integral;
-  __result.__last = __format_spec::__to_buffer(__integral, __buffer.end(), __value, chars_format::general, __precision);
+  __result.__last = __formatter::__to_buffer(__integral, __buffer.end(), __value, chars_format::general, __precision);
 
   char* __first = __integral + 1;
   if (__first == __result.__last) {
     __result.__radix_point = __result.__last;
     __result.__exponent = __result.__last;
   } else {
-    __result.__exponent = __format_spec::__find_exponent(__first, __result.__last);
+    __result.__exponent = __formatter::__find_exponent(__first, __result.__last);
     if (__result.__exponent != __result.__last)
       // In scientific mode if there's a radix point it will always be after
       // the first digit. (This is the position __first points at).
       __result.__radix_point = *__first == '.' ? __first : __result.__last;
     else {
       // In fixed mode the algorithm truncates trailing spaces and possibly the
       // radix point. There's no good guess for the position of the radix point
       // therefore scan the output after the first digit.
_LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_general_lower_case(__float_buffer<_Fp>& __buffer, _Tp __value,
   // clang-format on
 
   return __result;
 }
 
 template <class _Fp, class _Tp>
 _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_general_upper_case(__float_buffer<_Fp>& __buffer, _Tp __value,
                                                                         int __precision, char* __integral) {
-  __float_result __result =
-      __format_spec::__format_buffer_general_lower_case(__buffer, __value, __precision, __integral);
+  __float_result __result = __formatter::__format_buffer_general_lower_case(__buffer, __value, __precision, __integral);
   if (__result.__exponent != __result.__last)
     *__result.__exponent = 'E';
   return __result;
 }
 
+/// Fills the buffer with the data based on the requested formatting.
+///
+/// This function, when needed, turns the characters to upper case and
+/// determines the "interesting" locations which are returned to the caller.
+///
+/// This means the caller never has to convert the contents of the buffer to
+/// upper case or search for radix points and the location of the exponent.
+/// This gives a bit of overhead. The original code didn't do that, but due
+/// to the number of possible additional work needed to turn this number to
+/// the proper output the code was littered with tests for upper cases and
+/// searches for radix points and exponents.
+/// - When a precision larger than the type's precision is selected
+///   additional zero characters need to be written before the exponent.
+/// - alternate form needs to add a radix point when not present.
+/// - localization needs to do grouping in the integral part.
+template <class _Fp, class _Tp>
+// TODO FMT _Fp should just be _Tp when to_chars has proper long double support.
+_LIBCPP_HIDE_FROM_ABI __float_result __format_buffer(__float_buffer<_Fp>& __buffer, _Tp __value, bool __negative,
+                                                     bool __has_precision, __format_spec::__sign __sign,
+                                                     __format_spec::__type __type) {
+  char* __first = __insert_sign(__buffer.begin(), __negative, __sign);
+  switch (__type) {
+  case __format_spec::__type::__default:
+    return __formatter::__format_buffer_default(__buffer, __value, __first);
+
+  case __format_spec::__type::__float_hexadecimal_lower_case:
+    return __formatter::__format_buffer_hexadecimal_lower_case(__buffer, __value,
+                                                               __has_precision ? __buffer.__precision() : -1, __first);
+
+  case __format_spec::__type::__float_hexadecimal_upper_case:
+    return __formatter::__format_buffer_hexadecimal_upper_case(__buffer, __value,
+                                                               __has_precision ? __buffer.__precision() : -1, __first);
+
+  case __format_spec::__type::__scientific_lower_case:
+    return __formatter::__format_buffer_scientific_lower_case(__buffer, __value, __buffer.__precision(), __first);
+
+  case __format_spec::__type::__scientific_upper_case:
+    return __formatter::__format_buffer_scientific_upper_case(__buffer, __value, __buffer.__precision(), __first);
+
+  case __format_spec::__type::__fixed_lower_case:
+  case __format_spec::__type::__fixed_upper_case:
+    return __formatter::__format_buffer_fixed(__buffer, __value, __buffer.__precision(), __first);
+
+  case __format_spec::__type::__general_lower_case:
+    return __formatter::__format_buffer_general_lower_case(__buffer, __value, __buffer.__precision(), __first);
+
+  case __format_spec::__type::__general_upper_case:
+    return __formatter::__format_buffer_general_upper_case(__buffer, __value, __buffer.__precision(), __first);
+
+  default:
+    _LIBCPP_ASSERT(false, "The parser should have validated the type");
+    __libcpp_unreachable();
+  }
+}
+
 #    ifndef _LIBCPP_HAS_NO_LOCALIZATION
 template <class _OutIt, class _Fp, class _CharT>
 _LIBCPP_HIDE_FROM_ABI _OutIt __format_locale_specific_form(_OutIt __out_it, const __float_buffer<_Fp>& __buffer,
                                                            const __float_result& __result, _VSTD::locale __loc,
-                                                           size_t __width, _Flags::_Alignment __alignment,
-                                                           _CharT __fill) {
+                                                           __format_spec::__parser<_CharT> __parser) {
   const auto& __np = use_facet<numpunct<_CharT>>(__loc);
   string __grouping = __np.grouping();
   char* __first = __result.__integral;
   // When no radix point or exponent are present __last will be __result.__last.
   char* __last = _VSTD::min(__result.__radix_point, __result.__exponent);
 
   ptrdiff_t __digits = __last - __first;
   if (!__grouping.empty()) {
     if (__digits <= __grouping[0])
       __grouping.clear();
     else
-      __grouping = __determine_grouping(__digits, __grouping);
+      __grouping = __formatter::__determine_grouping(__digits, __grouping);
   }
 
-  size_t __size = __result.__last - __buffer.begin() + // Formatted string
+  ptrdiff_t __size = __result.__last - __buffer.begin() + // Formatted string
                      __buffer.__num_trailing_zeros() +    // Not yet rendered zeros
                      __grouping.size() -                  // Grouping contains one
                      !__grouping.empty();                 // additional character
 
   __formatter::__padding_size_result __padding = {0, 0};
-  bool __zero_padding = __alignment == _Flags::_Alignment::__default;
-  if (__size < __width) {
+  bool __zero_padding = __parser.__alignment_ == __format_spec::__alignment::__default;
+  if (__size < __parser.__width_) {
     if (__zero_padding) {
-      __alignment = _Flags::_Alignment::__right;
-      __fill = _CharT('0');
+      __parser.__alignment_ = __format_spec::__alignment::__right;
+      __parser.__fill_ = _CharT('0');
     }
 
-    __padding = __formatter::__padding_size(__size, __width, __alignment);
+    __padding = __padding_size(__size, __parser.__width_, __parser.__alignment_);
   }
 
   // sign and (zero padding or alignment)
   if (__zero_padding && __first != __buffer.begin())
     *__out_it++ = *__buffer.begin();
-  __out_it = _VSTD::fill_n(_VSTD::move(__out_it), __padding.__before, __fill);
+  __out_it = _VSTD::fill_n(_VSTD::move(__out_it), __padding.__before_, __parser.__fill_);
   if (!__zero_padding && __first != __buffer.begin())
     *__out_it++ = *__buffer.begin();
 
   // integral part
   if (__grouping.empty()) {
     __out_it = _VSTD::copy_n(__first, __digits, _VSTD::move(__out_it));
   } else {
     auto __r = __grouping.rbegin();
if (__result.__radix_point != __result.__last) {
     __out_it = _VSTD::fill_n(_VSTD::move(__out_it), __buffer.__num_trailing_zeros(), _CharT('0'));
   }
 
   // exponent
   if (__result.__exponent != __result.__last)
     __out_it = _VSTD::copy(__result.__exponent, __result.__last, _VSTD::move(__out_it));
 
   // alignment
-  return _VSTD::fill_n(_VSTD::move(__out_it), __padding.__after, __fill);
+  return _VSTD::fill_n(_VSTD::move(__out_it), __padding.__after_, __parser.__fill_);
 }
-
 #    endif // _LIBCPP_HAS_NO_LOCALIZATION
 
-template <__formatter::__char_type _CharT>
-class _LIBCPP_TEMPLATE_VIS __formatter_floating_point : public __parser_floating_point<_CharT> {
-public:
-  template <floating_point _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));
+template <class _OutIt, class _CharT>
+_LIBCPP_HIDE_FROM_ABI _OutIt __format_floating_point_non_finite(_OutIt __out_it,
+                                                                __format_spec::__parser<_CharT> __parser,
+                                                                bool __negative, bool __isnan) {
+  char __buffer[4];
+  char* __last = __formatter::__insert_sign(__buffer, __negative, __parser.__sign_);
+
+  // to_chars can return inf, infinity, nan, and nan(n-char-sequence).
+  // The format library requires inf and nan.
+  // All in one expression to avoid dangling references.
+  __last =
+      _VSTD::copy_n(&("infnanINFNAN"[6 * (__parser.__type_ == __format_spec::__type::__float_hexadecimal_upper_case ||
+                                          __parser.__type_ == __format_spec::__type::__scientific_upper_case ||
+                                          __parser.__type_ == __format_spec::__type::__fixed_upper_case ||
+                                          __parser.__type_ == __format_spec::__type::__general_upper_case) +
+                                     3 * __isnan]),
+                    3, __last);
+
+  // [format.string.std]/13
+  // A zero (0) character preceding the width field pads the field with
+  // leading zeros (following any indication of sign or base) to the field
+  // width, except when applied to an infinity or NaN.
+  if (__parser.__alignment_ == __format_spec::__alignment::__default)
+    __parser.__alignment_ = __format_spec::__alignment::__right;
+
+  return __formatter::__write(__buffer, __last, _VSTD::move(__out_it), __parser);
+}
+
+template <floating_point _Tp, class _CharT>
+_LIBCPP_HIDE_FROM_ABI auto __format_floating_point(_Tp __value, auto& __ctx, __format_spec::__parser<_CharT> __parser)
+    -> decltype(__ctx.out()) {
 
-    bool __negative = _VSTD::signbit(__value);
 
-    if (!_VSTD::isfinite(__value)) [[unlikely]]
-      return __format_non_finite(__ctx.out(), __negative, _VSTD::isnan(__value));
-
-    bool __has_precision = this->__has_precision_field();
-    if (this->__precision_needs_substitution())
-      this->__substitute_precision_arg_id(__ctx.arg(this->__precision));
+    return __formatter::__format_floating_point_non_finite(__ctx.out(), __parser, __negative, _VSTD::isnan(__value));
 
-    // Depending on the std-format-spec string the sign and the value
-    // might not be outputted together:
-    // - zero-padding may insert additional '0' characters.
-    // Therefore the value is processed as a non negative value.
-    // The function @ref __insert_sign will insert a '-' when the value was
-    // negative.
 
-    if (__negative)
-      __value = _VSTD::copysign(__value, +1.0);
+    __value = -__value;
 
-    // TODO FMT _Fp should just be _Tp when to_chars has proper long double support.
-    using _Fp = conditional_t<same_as<_Tp, long double>, double, _Tp>;
-    // Force the type of the precision to avoid -1 to become an unsigned value.
-    __float_buffer<_Fp> __buffer(__has_precision ? int(this->__precision) : -1);
-    __float_result __result = __format_buffer(__buffer, __value, __negative, __has_precision);
+  __float_buffer<_Fp> __buffer(__parser.__precision_);
+  __float_result __result = __formatter::__format_buffer(__buffer, __value, __negative, (__parser.__has_precision()),
+                                                         __parser.__sign_, __parser.__type_);
 
-    if (this->__alternate_form && __result.__radix_point == __result.__last) {
-      *__result.__last++ = '.';
+  if (__parser.__alternate_form_ && __result.__radix_point == __result.__last) {
 
-      // When there is an exponent the point needs to be moved before the
-      // exponent. When there's no exponent the rotate does nothing. Since
-      // rotate tests whether the operation is a nop, call it unconditionally.
-      _VSTD::rotate(__result.__exponent, __result.__last - 1, __result.__last);
-      __result.__radix_point = __result.__exponent;
 
-      // The radix point is always placed before the exponent.
-      // - No exponent needs to point to the new last.
-      // - An exponent needs to move one position to the right.
-      // So it's safe to increment the value unconditionally.
-      ++__result.__exponent;
-    }
 
 #    ifndef _LIBCPP_HAS_NO_LOCALIZATION
-    if (this->__locale_specific_form)
-      return __format_spec::__format_locale_specific_form(__ctx.out(), __buffer, __result, __ctx.locale(),
-                                                          this->__width, this->__alignment, this->__fill);
+  if (__parser.__locale_specific_form_)
+    return __formatter::__format_locale_specific_form(__ctx.out(), __buffer, __result, __ctx.locale(), __parser);
 #    endif
 
-    ptrdiff_t __size = __result.__last - __buffer.begin();
-    int __num_trailing_zeros = __buffer.__num_trailing_zeros();
-    if (__size + __num_trailing_zeros >= this->__width) {
-      if (__num_trailing_zeros && __result.__exponent != __result.__last)
-        // Insert trailing zeros before exponent character.
-        return _VSTD::copy(__result.__exponent, __result.__last,
-                           _VSTD::fill_n(_VSTD::copy(__buffer.begin(), __result.__exponent, __ctx.out()),
-                                         __num_trailing_zeros, _CharT('0')));
+  if (__size + __num_trailing_zeros >= __parser.__width_) {
 
-      return _VSTD::fill_n(_VSTD::copy(__buffer.begin(), __result.__last, __ctx.out()), __num_trailing_zeros,
-                           _CharT('0'));
-    }
 
-    auto __out_it = __ctx.out();
-    char* __first = __buffer.begin();
-    if (this->__alignment == _Flags::_Alignment::__default) {
-      // When there is a sign output it before the padding. Note the __size
-      // doesn't need any adjustment, regardless whether the sign is written
-      // here or in __formatter::__write.
-      if (__first != __result.__integral)
-        *__out_it++ = *__first++;
-      // After the sign is written, zero padding is the same a right alignment
-      // with '0'.
-      this->__alignment = _Flags::_Alignment::__right;
-      this->__fill = _CharT('0');
-    }
+  if (__parser.__alignment_ == __format_spec::__alignment ::__default) {
+    __parser.__alignment_ = __format_spec::__alignment::__right;
+    __parser.__fill_ = _CharT('0');
 
-    if (__num_trailing_zeros)
-      return __formatter::__write(_VSTD::move(__out_it), __first, __result.__last, __size, this->__width, this->__fill,
-                                  this->__alignment, __result.__exponent, __num_trailing_zeros);
+    return __formatter::__write_using_trailing_zeros(__first, __result.__last, _VSTD::move(__out_it), __parser, __size,
+                                                     __result.__exponent, __num_trailing_zeros);
 
-    return __formatter::__write(_VSTD::move(__out_it), __first, __result.__last, __size, this->__width, this->__fill,
-                                this->__alignment);
-  }
+  return __formatter::__write(__first, __result.__last, _VSTD::move(__out_it), __parser, __size);
 
-private:
-  template <class _OutIt>
-  _LIBCPP_HIDE_FROM_ABI _OutIt __format_non_finite(_OutIt __out_it, bool __negative, bool __isnan) {
-    char __buffer[4];
-    char* __last = __insert_sign(__buffer, __negative, this->__sign);
-
-    // to_char can return inf, infinity, nan, and nan(n-char-sequence).
-    // The format library requires inf and nan.
-    // All in one expression to avoid dangling references.
-    __last = _VSTD::copy_n(&("infnanINFNAN"[6 * (this->__type == _Flags::_Type::__float_hexadecimal_upper_case ||
-                                                 this->__type == _Flags::_Type::__scientific_upper_case ||
-                                                 this->__type == _Flags::_Type::__fixed_upper_case ||
-                                                 this->__type == _Flags::_Type::__general_upper_case) +
-                                            3 * __isnan]),
-                           3, __last);
+} // namespace __formatter
 
-    // [format.string.std]/13
-    // A zero (0) character preceding the width field pads the field with
-    // leading zeros (following any indication of sign or base) to the field
-    // width, except when applied to an infinity or NaN.
-    if (this->__alignment == _Flags::_Alignment::__default)
-      this->__alignment = _Flags::_Alignment::__right;
-
-    ptrdiff_t __size = __last - __buffer;
-    if (__size >= this->__width)
-      return _VSTD::copy_n(__buffer, __size, _VSTD::move(__out_it));
-
-    return __formatter::__write(_VSTD::move(__out_it), __buffer, __last, __size, this->__width, this->__fill,
-                                this->__alignment);
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS __formatter_floating_point {
+public:
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    auto __result = __parser_.__parse(__parse_ctx, __format_spec::__fields_floating_point);
+    __format_spec::__process_parsed_floating_point(__parser_);
+    return __result;
   }
 
-  /// Fills the buffer with the data based on the requested formatting.
-  ///
-  /// This function, when needed, turns the characters to upper case and
-  /// determines the "interesting" locations which are returned to the caller.
-  ///
-  /// This means the caller never has to convert the contents of the buffer to
-  /// upper case or search for radix points and the location of the exponent.
-  /// This gives a bit of overhead. The original code didn't do that, but due
-  /// to the number of possible additional work needed to turn this number to
-  /// the proper output the code was littered with tests for upper cases and
-  /// searches for radix points and exponents.
-  /// - When a precision larger than the type's precision is selected
-  ///   additional zero characters need to be written before the exponent.
-  /// - alternate form needs to add a radix point when not present.
-  /// - localization needs to do grouping in the integral part.
-  template <class _Fp, class _Tp>
-  // TODO FMT _Fp should just be _Tp when to_chars has proper long double support.
-  _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer(__float_buffer<_Fp>& __buffer, _Tp __value, bool __negative,
-                                                       bool __has_precision) {
-    char* __first = __insert_sign(__buffer.begin(), __negative, this->__sign);
-    switch (this->__type) {
-    case _Flags::_Type::__default:
-      return __format_spec::__format_buffer_default(__buffer, __value, __first);
-
-    case _Flags::_Type::__float_hexadecimal_lower_case:
-      return __format_spec::__format_buffer_hexadecimal_lower_case(
-          __buffer, __value, __has_precision ? __buffer.__precision() : -1, __first);
-
-    case _Flags::_Type::__float_hexadecimal_upper_case:
-      return __format_spec::__format_buffer_hexadecimal_upper_case(
-          __buffer, __value, __has_precision ? __buffer.__precision() : -1, __first);
-
-    case _Flags::_Type::__scientific_lower_case:
-      return __format_spec::__format_buffer_scientific_lower_case(__buffer, __value, __buffer.__precision(), __first);
-
-    case _Flags::_Type::__scientific_upper_case:
-      return __format_spec::__format_buffer_scientific_upper_case(__buffer, __value, __buffer.__precision(), __first);
-
-    case _Flags::_Type::__fixed_lower_case:
-    case _Flags::_Type::__fixed_upper_case:
-      return __format_spec::__format_buffer_fixed(__buffer, __value, __buffer.__precision(), __first);
-
-    case _Flags::_Type::__general_lower_case:
-      return __format_spec::__format_buffer_general_lower_case(__buffer, __value, __buffer.__precision(), __first);
-
-    case _Flags::_Type::__general_upper_case:
-      return __format_spec::__format_buffer_general_upper_case(__buffer, __value, __buffer.__precision(), __first);
-
-    default:
-      _LIBCPP_ASSERT(false, "The parser should have validated the type");
-      __libcpp_unreachable();
-    }
+  template <floating_point _Tp>
+  _LIBCPP_HIDE_FROM_ABI auto format(_Tp __value, auto& __ctx) const -> decltype(__ctx.out()) {
+    return __formatter::__format_floating_point(__value, __ctx, __parser_.__resolve_dynamic_sizes(__ctx));
   }
-};
 
-} //namespace __format_spec
+  __format_spec::__parser<_CharT> __parser_;
+};
 
 template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<float, _CharT>
-    : public __format_spec::__formatter_floating_point<_CharT> {};
+    : public __formatter_floating_point<_CharT> {};
 template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<double, _CharT>
-    : public __format_spec::__formatter_floating_point<_CharT> {};
+    : public __formatter_floating_point<_CharT> {};
 template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<long double, _CharT>
-    : public __format_spec::__formatter_floating_point<_CharT> {};
+    : public __formatter_floating_point<_CharT> {};
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___FORMAT_FORMATTER_FLOATING_POINT_H

libcxx/include/__format/formatter_integer.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_INTEGER_H
 #define _LIBCPP___FORMAT_FORMATTER_INTEGER_H
 
 #include <__availability>
+#include <__concepts/arithmetic.h>
 #include <__config>
-#include <__format/format_error.h>
+#include <__format/format_error.h> // TODO FMT Remove after adding 128-bit support
 #include <__format/format_fwd.h>
+#include <__format/format_parse_context.h>
 #include <__format/formatter.h>
 #include <__format/formatter_integral.h>
+#include <__format/formatter_output.h>
 #include <__format/parser_std_format_spec.h>
-#include <limits>
+#include <limits> // TODO FMT Remove after adding 128-bit support
+#include <type_traits> // is_signed_v
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-_LIBCPP_PUSH_MACROS
+_LIBCPP_PUSH_MACROS // TODO FMT Remove after adding 128-bit support
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
-namespace __format_spec {
-
-template <class _CharT>
-class _LIBCPP_TEMPLATE_VIS __parser_integer : public __parser_integral<_CharT> {
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __formatter_integer {
 public:
-  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(auto& __parse_ctx)
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
       -> decltype(__parse_ctx.begin()) {
-    auto __it = __parser_integral<_CharT>::__parse(__parse_ctx);
-
-    switch (this->__type) {
-    case _Flags::_Type::__default:
-      this->__type = _Flags::_Type::__decimal;
-      [[fallthrough]];
-
-    case _Flags::_Type::__binary_lower_case:
-    case _Flags::_Type::__binary_upper_case:
-    case _Flags::_Type::__octal:
-    case _Flags::_Type::__decimal:
-    case _Flags::_Type::__hexadecimal_lower_case:
-    case _Flags::_Type::__hexadecimal_upper_case:
-      this->__handle_integer();
-      break;
-
-    case _Flags::_Type::__char:
-      this->__handle_char();
-      break;
-
-    default:
-      __throw_format_error("The format-spec type has a type not supported for "
-                           "an integer argument");
-    }
-    return __it;
+    auto __result = __parser_.__parse(__parse_ctx, __format_spec::__fields_integral);
+    __format_spec::__process_parsed_integer(__parser_);
+    return __result;
+
+  // TODO might want to reduce the number of instantiations
+  // but need to measure the size of them (eg 64 bit and 128 bit version)
+  // One formatter integral and char
+  template <integral _Tp>
+  _LIBCPP_HIDE_FROM_ABI auto format(_Tp __value, auto& __ctx) const -> decltype(__ctx.out()) {
+    return format(__value, __ctx, __parser_.__resolve_dynamic_sizes(__ctx));
   }
-};
 
-template <class _CharT>
-using __formatter_integer = __formatter_integral<__parser_integer<_CharT>>;
+  template <integral _Tp>
+  static _LIBCPP_HIDE_FROM_ABI auto format(_Tp __value, auto& __ctx, __format_spec::__parser<_CharT> __parser)
+      -> decltype(__ctx.out()) {
+    if (__parser.__type_ == __format_spec::__type::__char)
+      return __formatter::__format_char(__value, __ctx.out(), __parser);
 
-} // namespace __format_spec
+    // Reduce the number of instantiation of the integer formatter
+    if constexpr (is_signed_v<_Tp>) {
+      if constexpr (sizeof(_Tp) <= sizeof(int))
+        return __formatter::__format_integer(static_cast<int>(__value), __ctx, __parser);
+      else if constexpr (sizeof(_Tp) <= sizeof(long long))
+        return __formatter::__format_integer(static_cast<long long>(__value), __ctx, __parser);
+#    ifndef _LIBCPP_HAS_NO_INT128
+      else if constexpr (sizeof(_Tp) <= sizeof(__int128_t))
+        return __formatter::__format_integer(static_cast<__int128_t>(__value), __ctx, __parser);
+#    endif
+      else
+        static_assert(sizeof(_Tp) == 0, "Unsupported type");
+    } else {
+      if constexpr (sizeof(_Tp) <= sizeof(unsigned))
+        return __formatter::__format_integer(static_cast<unsigned>(__value), __ctx, __parser);
+      else if constexpr (sizeof(_Tp) <= sizeof(unsigned long long))
+        return __formatter::__format_integer(static_cast<unsigned long long>(__value), __ctx, __parser);
+#    ifndef _LIBCPP_HAS_NO_INT128
+      else if constexpr (sizeof(_Tp) <= sizeof(__uint128_t))
+        return __formatter::__format_integer(static_cast<__uint128_t>(__value), __ctx, __parser);
+#    endif
+      else
+        static_assert(sizeof(_Tp) == 0, "Unsupported type");
+    }
+  }
 
-// [format.formatter.spec]/2.3
-// For each charT, for each cv-unqualified arithmetic type ArithmeticT other
-// than char, wchar_t, char8_t, char16_t, or char32_t, a specialization
+  __format_spec::__parser<_CharT> __parser_;
+};
 
 // Signed integral types.
 template <__formatter::__char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
-    formatter<signed char, _CharT>
-    : public __format_spec::__formatter_integer<_CharT> {};
-template <__formatter::__char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<short, _CharT>
-    : public __format_spec::__formatter_integer<_CharT> {};
-template <__formatter::__char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<int, _CharT>
-    : public __format_spec::__formatter_integer<_CharT> {};
-template <__formatter::__char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<long, _CharT>
-    : public __format_spec::__formatter_integer<_CharT> {};
-template <__formatter::__char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
-    formatter<long long, _CharT>
-    : public __format_spec::__formatter_integer<_CharT> {};
-#ifndef _LIBCPP_HAS_NO_INT128
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<signed char, _CharT>
+    : public __formatter_integer<_CharT> {};
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<short, _CharT> : public __formatter_integer<_CharT> {
+};
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<int, _CharT> : public __formatter_integer<_CharT> {};
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<long, _CharT> : public __formatter_integer<_CharT> {};
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<long long, _CharT>
+    : public __formatter_integer<_CharT> {};
+#    ifndef _LIBCPP_HAS_NO_INT128
 template <__formatter::__char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
-    formatter<__int128_t, _CharT>
-    : public __format_spec::__formatter_integer<_CharT> {
-  using _Base = __format_spec::__formatter_integer<_CharT>;
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<__int128_t, _CharT>
+    : public __formatter_integer<_CharT> {
+  using _Base = __formatter_integer<_CharT>;
 
-  _LIBCPP_HIDE_FROM_ABI auto format(__int128_t __value, auto& __ctx)
-      -> decltype(__ctx.out()) {
+  _LIBCPP_HIDE_FROM_ABI auto format(__int128_t __value, auto& __ctx) const -> decltype(__ctx.out()) {
     // TODO FMT Implement full 128 bit support.
     using _To = long long;
-    if (__value < numeric_limits<_To>::min() ||
-        __value > numeric_limits<_To>::max())
+    if (__value < numeric_limits<_To>::min() || __value > numeric_limits<_To>::max())
       __throw_format_error("128-bit value is outside of implemented range");
 
     return _Base::format(static_cast<_To>(__value), __ctx);
   }
 };
-#endif
+#    endif
 
 // Unsigned integral types.
 template <__formatter::__char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
-    formatter<unsigned char, _CharT>
-    : public __format_spec::__formatter_integer<_CharT> {};
-template <__formatter::__char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
-    formatter<unsigned short, _CharT>
-    : public __format_spec::__formatter_integer<_CharT> {};
-template <__formatter::__char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
-    formatter<unsigned, _CharT>
-    : public __format_spec::__formatter_integer<_CharT> {};
-template <__formatter::__char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
-    formatter<unsigned long, _CharT>
-    : public __format_spec::__formatter_integer<_CharT> {};
-template <__formatter::__char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
-    formatter<unsigned long long, _CharT>
-    : public __format_spec::__formatter_integer<_CharT> {};
-#ifndef _LIBCPP_HAS_NO_INT128
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<unsigned char, _CharT>
+    : public __formatter_integer<_CharT> {};
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<unsigned short, _CharT>
+    : public __formatter_integer<_CharT> {};
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<unsigned, _CharT>
+    : public __formatter_integer<_CharT> {};
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<unsigned long, _CharT>
+    : public __formatter_integer<_CharT> {};
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<unsigned long long, _CharT>
+    : public __formatter_integer<_CharT> {};
+#    ifndef _LIBCPP_HAS_NO_INT128
 template <__formatter::__char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
-    formatter<__uint128_t, _CharT>
-    : public __format_spec::__formatter_integer<_CharT> {
-  using _Base = __format_spec::__formatter_integer<_CharT>;
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<__uint128_t, _CharT>
+    : public __formatter_integer<_CharT> {
+  using _Base = __formatter_integer<_CharT>;
 
-  _LIBCPP_HIDE_FROM_ABI auto format(__uint128_t __value, auto& __ctx)
-      -> decltype(__ctx.out()) {
+  _LIBCPP_HIDE_FROM_ABI auto format(__uint128_t __value, auto& __ctx) const -> decltype(__ctx.out()) {
     // TODO FMT Implement full 128 bit support.
     using _To = unsigned long long;
-    if (__value < numeric_limits<_To>::min() ||
-        __value > numeric_limits<_To>::max())
+    if (__value < numeric_limits<_To>::min() || __value > numeric_limits<_To>::max())
       __throw_format_error("128-bit value is outside of implemented range");
 
     return _Base::format(static_cast<_To>(__value), __ctx);
   }
 };
-#endif
+#    endif
 
+
+
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___FORMAT_FORMATTER_INTEGER_H

libcxx/include/__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 <__algorithm/copy.h>
-#include <__algorithm/copy_n.h>
-#include <__algorithm/fill_n.h>
-#include <__algorithm/transform.h>
-#include <__assert>
 #include <__config>
 #include <__format/format_error.h>
-#include <__format/format_fwd.h>
-#include <__format/formatter.h>
+#include <__format/format_fwd.h> // for __char_type TODO FMT Move the concept?
+#include <__format/formatter_output.h>
 #include <__format/parser_std_format_spec.h>
 #include <__utility/unreachable.h>
-#include <array>
 #include <charconv>
-#include <concepts>
 #include <limits>
-#include <string>
 
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
-#include <locale>
+#  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
 
-/**
- * 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 <integral _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;
-}
+namespace __formatter {
 
-/**
- * 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.
-}
+//
+// Generic
+//
 
-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.
+_LIBCPP_HIDE_FROM_ABI inline char* __insert_sign(char* __buf, bool __negative, __format_spec::__sign __sign) {
+  if (__negative)
+    *__buf++ = '-';
+  else
+    switch (__sign) {
+    case __format_spec::__sign::__default:
+    case __format_spec::__sign::__minus:
+      // No sign added.
+      break;
+    case __format_spec::__sign::__plus:
+      *__buf++ = '+';
+      break;
+    case __format_spec::__sign::__space:
+      *__buf++ = ' ';
+      break;
     }
 
-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.
+  return __buf;
 }
 
 /**
  * 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_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) {
if (__ptr != __end) {
         // 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;
+//
+// Char
+//
 
-    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");
-      }
-    }
+template <__formatter::__char_type _CharT>
+_LIBCPP_HIDE_FROM_ABI auto __format_char(integral auto __value, output_iterator<const _CharT&> auto __out_it,
+                                         __format_spec::__parser<_CharT> __parser) -> decltype(__out_it) {
+      if (__value < numeric_limits<_CharT>::min() || __value > numeric_limits<_CharT>::max())
+        __throw_format_error("Integral value outside the range of the char type");
+      if (__value > static_cast<make_unsigned_t<_CharT>>(numeric_limits<_CharT>::max()))
+        __throw_format_error("Integral value outside the range of the char type");
+      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());
-  }
+  return __formatter::__write(_VSTD::addressof(__c), _VSTD::addressof(__c) + 1, _VSTD::move(__out_it), __parser);
+}
+
+//
+// Integer
+//
+
+/** Wrapper around @ref to_chars, returning the output pointer. */
+template <integral _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;
 
-  /**
-   * 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();
-    }
-  }
+ * 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>
+consteval 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>
+consteval 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>
+consteval 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>
+consteval 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.
 
-  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++;
+template <unsigned_integral _Tp, class _CharT>
+_LIBCPP_HIDE_FROM_ABI auto __format_integer(_Tp __value, auto& __ctx, __format_spec::__parser<_CharT> __parser,
+                                            bool __negative, char* __begin, char* __end, const char* __prefix,
+                                            int __base) -> decltype(__ctx.out()) {
+  char* __first = __formatter::__insert_sign(__begin, __negative, __parser.__sign_);
+  if (__parser.__alternate_form_ && __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);
-    }
+  char* __last = __formatter::__to_buffer(__first, __end, __value, __base);
+
+#    ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  if (__parser.__locale_specific_form_) {
+      return __formatter::__write_using_decimal_separators(__ctx.out(), __begin, __first, __last,
+                                                           __formatter::__determine_grouping(__size, __grouping),
+                                                           __np.thousands_sep(), __parser);
+#    endif
+  if (__parser.__alignment_ != __format_spec::__alignment::__default)
+    __parser.__alignment_ = __format_spec::__alignment::__right;
+    __parser.__fill_ = _CharT('0');
+    int32_t __size = __first - __begin;
 
-    return __write(__first, __last, _VSTD::move(__out_it));
+    __parser.__width_ -= _VSTD::min(__size, __parser.__width_);
   }
 
-#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 (__parser.__type_ != __format_spec::__type::__hexadecimal_upper_case) [[likely]]
+    return __formatter::__write(__first, __last, __ctx.out(), __parser);
 
-      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);
+  return __formatter::__write_transformed(__first, __last, __ctx.out(), __parser, __formatter::__hex_to_upper);
 
-        __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;
-      }
+template <unsigned_integral _Tp, class _CharT>
+_LIBCPP_HIDE_FROM_ABI auto __format_integer(_Tp __value, auto& __ctx, __format_spec::__parser<_CharT> __parser,
+                                            bool __negative = false) -> decltype(__ctx.out()) {
+
+  switch (__parser.__type_) {
+  case __format_spec::__type::__binary_lower_case: {
+    array<char, __formatter::__buffer_size<decltype(__value), 2>()> __array;
+    return __formatter::__format_integer(__value, __ctx, __parser, __negative, __array.begin(), __array.end(), "0b", 2);
+  case __format_spec::__type::__binary_upper_case: {
+    array<char, __formatter::__buffer_size<decltype(__value), 2>()> __array;
+    return __formatter::__format_integer(__value, __ctx, __parser, __negative, __array.begin(), __array.end(), "0B", 2);
+  }
+  case __format_spec::__type::__octal: {
+    // Octal is special; if __value == 0 there's no prefix.
+    array<char, __formatter::__buffer_size<decltype(__value), 8>()> __array;
+    return __formatter::__format_integer(__value, __ctx, __parser, __negative, __array.begin(), __array.end(),
+                                         __value != 0 ? "0" : nullptr, 8);
+  }
+  case __format_spec::__type::__decimal: {
+    array<char, __formatter::__buffer_size<decltype(__value), 10>()> __array;
+    return __formatter::__format_integer(__value, __ctx, __parser, __negative, __array.begin(), __array.end(), nullptr,
+                                         10);
+  }
+  case __format_spec::__type::__hexadecimal_lower_case: {
+    array<char, __formatter::__buffer_size<decltype(__value), 16>()> __array;
+    return __formatter::__format_integer(__value, __ctx, __parser, __negative, __array.begin(), __array.end(), "0x",
+                                         16);
+  }
+  case __format_spec::__type::__hexadecimal_upper_case: {
+    array<char, __formatter::__buffer_size<decltype(__value), 16>()> __array;
+    return __formatter::__format_integer(__value, __ctx, __parser, __negative, __array.begin(), __array.end(), "0X",
+                                         16);
+  }
+  default:
+    _LIBCPP_ASSERT(false, "The parse function should have validated the type");
+    __libcpp_unreachable();
 
-      if (__r == __e)
-        break;
+template <signed_integral _Tp, class _CharT>
+_LIBCPP_HIDE_FROM_ABI auto __format_integer(_Tp __value, auto& __ctx, __format_spec::__parser<_CharT> __parser)
+    -> decltype(__ctx.out()) {
+  // 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);
 
-      ++__r;
-      *__out_it++ = __sep;
-    }
+  return __formatter::__format_integer(__r, __ctx, __parser, __negative);
 
-    return _VSTD::fill_n(_VSTD::move(__out_it), __padding.__after,
-                         this->__fill);
-  }
-#endif // _LIBCPP_HAS_NO_LOCALIZATION
+//
+// Formatter arithmetic (bool)
+//
+
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS __bool_strings;
+
+template <>
+struct _LIBCPP_TEMPLATE_VIS __bool_strings<char> {
+  static constexpr string_view __true{"true"};
+  static constexpr string_view __false{"false"};
 };
 
-} // namespace __format_spec
+#    ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <>
+struct _LIBCPP_TEMPLATE_VIS __bool_strings<wchar_t> {
+  static constexpr wstring_view __true{L"true"};
+  static constexpr wstring_view __false{L"false"};
+};
+#    endif
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI auto __format_bool(bool __value, auto& __ctx, __format_spec::__parser<_CharT> __parser) {
+
+#    ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  if (__parser.__locale_specific_form_) {
+    const auto& __np = use_facet<numpunct<_CharT>>(__ctx.locale());
+    basic_string<_CharT> __str = __value ? __np.truename() : __np.falsename();
+    return __formatter::__write_unicode_no_precision(basic_string_view<_CharT>{__str}, __ctx.out(), __parser);
+  }
+#    endif
+  basic_string_view<_CharT> __str =
+      __value ? __formatter::__bool_strings<_CharT>::__true : __formatter::__bool_strings<_CharT>::__false;
+  return __formatter::__write(__str.begin(), __str.end(), __ctx.out(), __parser);
+}
+
+} // namespace __formatter
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___FORMAT_FORMATTER_INTEGRAL_H

libcxx/include/__format/formatter_output.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_OUTPUT_H
+#define _LIBCPP___FORMAT_FORMATTER_OUTPUT_H
+
+#include <__algorithm/copy.h>
+#include <__algorithm/copy_n.h>
+#include <__algorithm/fill_n.h>
+#include <__algorithm/transform.h>
+#include <__concepts/same_as.h>
+#include <__config>
+#include <__format/format_string.h>
+#include <__format/parser_std_format_spec.h>
+#include <__utility/unreachable.h>
+#include <cstddef>
+#include <string>
+#include <string_view>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17
+
+namespace __formatter {
+
+_LIBCPP_HIDE_FROM_ABI constexpr char __hex_to_upper(char c) {
+  switch (c) {
+  case 'a':
+    return 'A';
+  case 'b':
+    return 'B';
+  case 'c':
+    return 'C';
+  case 'd':
+    return 'D';
+  case 'e':
+    return 'E';
+  case 'f':
+    return 'F';
+  }
+  return c;
+}
+
+struct _LIBCPP_TYPE_VIS __padding_size_result {
+  size_t __before_;
+  size_t __after_;
+};
+
+_LIBCPP_HIDE_FROM_ABI constexpr __padding_size_result __padding_size(size_t __size, size_t __width,
+                                                                     __format_spec::__alignment __align) {
+  _LIBCPP_ASSERT(__width > __size, "Don't call this function when no padding is required");
+  _LIBCPP_ASSERT(__align != __format_spec::__alignment::__default,
+                 "Caller should adjust the default to the value required by the type");
+
+  size_t __fill = __width - __size;
+  switch (__align) {
+  case __format_spec::__alignment::__default:
+    __libcpp_unreachable();
+
+  case __format_spec::__alignment::__left:
+    return {0, __fill};
+
+  case __format_spec::__alignment::__center: {
+    // The extra padding is divided per [format.string.std]/3
+    // __before = floor(__fill, 2);
+    // __after = ceil(__fill, 2);
+    size_t __before = __fill / 2;
+    size_t __after = __fill - __before;
+    return {__before, __after};
+  }
+  case __format_spec::__alignment::__right:
+    return {__fill, 0};
+  }
+  __libcpp_unreachable();
+}
+
+template <class _OutIt, class _CharT>
+_LIBCPP_HIDE_FROM_ABI _OutIt __write_using_decimal_separators(_OutIt __out_it, const char* __begin, const char* __first,
+                                                              const char* __last, string&& __grouping, _CharT __sep,
+                                                              __format_spec::__parser<_CharT> __parser) {
+  int __size = (__first - __begin) +    // [sign][prefix]
+               (__last - __first) +     // data
+               (__grouping.size() - 1); // number of separator characters
+
+  __padding_size_result __padding = {0, 0};
+  if (__parser.__alignment_ == __format_spec::__alignment::__default) {
+    // Write [sign][prefix].
+    __out_it = _VSTD::copy(__begin, __first, _VSTD::move(__out_it));
+
+    if (__parser.__width_ > __size) {
+      // Write zero padding.
+      __padding.__before_ = __parser.__width_ - __size;
+      __out_it = _VSTD::fill_n(_VSTD::move(__out_it), __parser.__width_ - __size, _CharT('0'));
+    }
+  } else {
+    if (__parser.__width_ > __size) {
+      // Determine padding and write padding.
+      __padding = __padding_size(__size, __parser.__width_, __parser.__alignment_);
+
+      __out_it = _VSTD::fill_n(_VSTD::move(__out_it), __padding.__before_, __parser.__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 `__parser.__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 (__parser.__type_ == __format_spec::__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_, __parser.__fill_);
+}
+
+/**
+ * Writes the input to the output with the required padding.
+ *
+ * Since the output column width is specified the function can be used for
+ * ASCII and Unicode input.
+ *
+ * @pre [@a __first, @a __last) is a valid range.
+ * @pre @a __size <= @a __width. Using this function when this pre-condition
+ *      doesn't hold incurs an unwanted overhead.
+ *
+ * @param __out_it    The output iterator to write to.
+ * @param __first     Pointer to the first element to write.
+ * @param __last      Pointer beyond the last element to write.
+ * @param __size      The (estimated) output column width. When the elements
+ *                    to be written are ASCII the following condition holds
+ *                    @a __size == @a __last - @a __first.
+ * @param __width     The number of output columns to write.
+ * @param __fill      The character used for the alignment of the output.
+ *                    TODO FMT Will probably change to support Unicode grapheme
+ *                    cluster.
+ * @param __alignment The requested alignment.
+ *
+ * @returns           An iterator pointing beyond the last element written.
+ *
+ * @note The type of the elements in range [@a __first, @a __last) can differ
+ * from the type of @a __fill. Integer output uses @c std::to_chars for its
+ * conversion, which means the [@a __first, @a __last) always contains elements
+ * of the type @c char.
+ */
+template <class _CharT, class _ParserCharT>
+_LIBCPP_HIDE_FROM_ABI auto __write(const _CharT* __first, const _CharT* __last,
+                                   output_iterator<const _CharT&> auto __out_it,
+                                   __format_spec::__parser<_ParserCharT> __parser, ptrdiff_t __size) {
+  _LIBCPP_ASSERT(__first <= __last, "Not a valid range");
+
+  if (__size >= __parser.__width_)
+    return _VSTD::copy(__first, __last, _VSTD::move(__out_it));
+
+  __padding_size_result __padding = __formatter::__padding_size(__size, __parser.__width_, __parser.__alignment_);
+  __out_it = _VSTD::fill_n(_VSTD::move(__out_it), __padding.__before_, __parser.__fill_);
+  __out_it = _VSTD::copy(__first, __last, _VSTD::move(__out_it));
+  return _VSTD::fill_n(_VSTD::move(__out_it), __padding.__after_, __parser.__fill_);
+}
+
+/** XXX update comment
+ * Writes the input to the output with the required padding.
+ *
+ * Since the output column width is specified the function can be used for
+ * ASCII and Unicode input.
+ *
+ * @pre [@a __first, @a __last) is a valid range.
+ * @pre @a __size <= @a __width. Using this function when this pre-condition
+ *      doesn't hold incurs an unwanted overhead.
+ *
+ * @param __out_it    The output iterator to write to.
+ * @param __first     Pointer to the first element to write.
+ * @param __last      Pointer beyond the last element to write.
+ * @param __size      The (estimated) output column width. When the elements
+ *                    to be written are ASCII the following condition holds
+ *                    @a __size == @a __last - @a __first.
+ * @param __width     The number of output columns to write.
+ * @param __fill      The character used for the alignment of the output.
+ *                    TODO FMT Will probably change to support Unicode grapheme
+ *                    cluster.
+ * @param __alignment The requested alignment.
+ *
+ * @returns           An iterator pointing beyond the last element written.
+ *
+ * @note The type of the elements in range [@a __first, @a __last) can differ
+ * from the type of @a __fill. Integer output uses @c std::to_chars for its
+ * conversion, which means the [@a __first, @a __last) always contains elements
+ * of the type @c char.
+ */
+// Ignores precision
+template <class _CharT, class _ParserCharT>
+_LIBCPP_HIDE_FROM_ABI auto __write(const _CharT* __first, const _CharT* __last,
+                                   output_iterator<const _CharT&> auto __out_it,
+                                   __format_spec::__parser<_ParserCharT> __parser) {
+  return __write(__first, __last, _VSTD::move(__out_it), __parser, __last - __first);
+}
+
+// Ignores precision
+template <class _CharT, class _ParserCharT, class _UnaryOperation>
+_LIBCPP_HIDE_FROM_ABI auto __write_transformed(const _CharT* __first, const _CharT* __last,
+                                               output_iterator<const _CharT&> auto __out_it,
+                                               __format_spec::__parser<_ParserCharT> __parser, _UnaryOperation __op) {
+  _LIBCPP_ASSERT(__first <= __last, "Not a valid range");
+  _LIBCPP_ASSERT(!__parser.__has_precision(), "Use XXXX");
+
+  ptrdiff_t __size = __last - __first;
+  if (__size >= __parser.__width_)
+    return _VSTD::transform(__first, __last, _VSTD::move(__out_it), __op);
+
+  __padding_size_result __padding = __padding_size(__size, __parser.__width_, __parser.__alignment_);
+  __out_it = _VSTD::fill_n(_VSTD::move(__out_it), __padding.__before_, __parser.__fill_);
+  __out_it = _VSTD::transform(__first, __last, _VSTD::move(__out_it), __op);
+  return _VSTD::fill_n(_VSTD::move(__out_it), __padding.__after_, __parser.__fill_);
+}
+
+/**
+ * @overload
+ *
+ * Writes additional zero's for the precision before the exponent.
+ * This is used when the precision requested in the format string is larger
+ * than the maximum precision of the floating-point type. These precision
+ * digits are always 0.
+ *
+ * @param __exponent           The location of the exponent character.
+ * @param __num_trailing_zeros The number of 0's to write before the exponent
+ *                             character.
+ */
+template <class _CharT, class _ParserCharT>
+_LIBCPP_HIDE_FROM_ABI auto __write_using_trailing_zeros(const _CharT* __first, const _CharT* __last,
+                                                        output_iterator<const _CharT&> auto __out_it,
+                                                        __format_spec::__parser<_ParserCharT> __parser, size_t __size,
+                                                        const _CharT* __exponent, size_t __num_trailing_zeros) {
+  _LIBCPP_ASSERT(__first <= __last, "Not a valid range");
+  _LIBCPP_ASSERT(__num_trailing_zeros > 0, "The overload not writing trailing zeros should have been used");
+
+  __padding_size_result __padding =
+      __padding_size(__size + __num_trailing_zeros, __parser.__width_, __parser.__alignment_);
+  __out_it = _VSTD::fill_n(_VSTD::move(__out_it), __padding.__before_, __parser.__fill_);
+  __out_it = _VSTD::copy(__first, __exponent, _VSTD::move(__out_it));
+  __out_it = _VSTD::fill_n(_VSTD::move(__out_it), __num_trailing_zeros, _CharT('0'));
+  __out_it = _VSTD::copy(__exponent, __last, _VSTD::move(__out_it));
+  return _VSTD::fill_n(_VSTD::move(__out_it), __padding.__after_, __parser.__fill_);
+}
+
+#    ifndef _LIBCPP_HAS_NO_UNICODE
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI auto __write_unicode_no_precision(basic_string_view<_CharT> __str,
+                                                        output_iterator<const _CharT&> auto __out_it,
+                                                        __format_spec::__parser<_CharT> __parser) {
+  _LIBCPP_ASSERT(!__parser.__has_precision(), "use __write_unicode");
+  // No padding -> copy the string
+  if (!__parser.__has_width())
+    return _VSTD::copy(__str.begin(), __str.end(), _VSTD::move(__out_it));
+
+  // Non Unicode part larger than width -> copy the string
+  auto __last = __format_spec::__detail::__estimate_column_width_fast(__str.begin(), __str.end());
+  ptrdiff_t __size = __last - __str.begin();
+  if (__size >= __parser.__width_)
+    return _VSTD::copy(__str.begin(), __str.end(), _VSTD::move(__out_it));
+
+  // Is there a non Unicode part?
+  if (__last != __str.end()) {
+    // Non Unicode and Unicode part larger than width -> copy the string
+    __format_spec::__detail::__column_width_result __column_width =
+        __format_spec::__detail::__estimate_column_width(__last, __str.end(), __parser.__width_);
+    __size += __column_width.__width; // Note this new size is used when __size < __parser.__width_
+    if (__size >= __parser.__width_)
+      return _VSTD::copy(__str.begin(), __str.end(), _VSTD::move(__out_it));
+  }
+
+  return __formatter::__write(__str.begin(), __str.end(), _VSTD::move(__out_it), __parser, __size);
+}
+#    endif
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI auto __write_unicode(basic_string_view<_CharT> __str,
+                                           output_iterator<const _CharT&> auto __out_it,
+                                           __format_spec::__parser<_CharT> __parser) {
+#    ifndef _LIBCPP_HAS_NO_UNICODE
+  if (!__parser.__has_precision())
+    return __formatter::__write_unicode_no_precision(__str, _VSTD::move(__out_it), __parser);
+
+  // Non unicode part larger than precision -> truncate the output and use the normal write operation.
+  auto __last = __format_spec::__detail::__estimate_column_width_fast(__str.begin(), __str.end());
+  ptrdiff_t __size = __last - __str.begin();
+  if (__size >= __parser.__precision_)
+    return __formatter::__write(__str.begin(), __str.begin() + __parser.__precision_, _VSTD::move(__out_it), __parser,
+                                __parser.__precision_);
+
+  // No non Unicode part, implies __size <  __parser.__precision_ -> use normal write operation
+  if (__last == __str.end())
+    return __formatter::__write(__str.begin(), __str.end(), _VSTD::move(__out_it), __parser, __str.size());
+
+  __format_spec::__detail::__column_width_result __column_width =
+      __format_spec::__detail::__estimate_column_width(__last, __str.end(), __parser.__precision_ - __size);
+  __size += __column_width.__width;
+  // Truncate the output
+  if (__column_width.__ptr != __str.end())
+    __str.remove_suffix(__str.end() - __column_width.__ptr);
+
+  return __formatter::__write(__str.begin(), __str.end(), _VSTD::move(__out_it), __parser, __size);
+
+#    else
+  if (__parser.__has_precision()) {
+    ptrdiff_t __size = __str.size();
+    if (__size > __parser.__precision_)
+      return __formatter::__write(__str.begin(), __str.begin() + __parser.__precision_, _VSTD::move(__out_it), __parser,
+                                  __parser.__precision_);
+  }
+  return __formatter::__write(__str.begin(), __str.end(), _VSTD::move(__out_it), __parser, __str.size());
+
+#    endif
+}
+
+} // namespace __formatter
+
+#endif //_LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FORMAT_FORMATTER_V2_H

libcxx/include/__format/formatter_pointer.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_POINTER_H
 #define _LIBCPP___FORMAT_FORMATTER_POINTER_H
 
-#include <__algorithm/copy.h>
-#include <__assert>
 #include <__availability>
 #include <__config>
-#include <__format/format_error.h>
 #include <__format/format_fwd.h>
+#include <__format/format_parse_context.h>
 #include <__format/formatter.h>
 #include <__format/formatter_integral.h>
+#include <__format/formatter_output.h>
 #include <__format/parser_std_format_spec.h>
-#include <__iterator/access.h>
 #include <cstddef>
 #include <cstdint>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
-namespace __format_spec {
+namespace __formatter {
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI auto __format_pointer(const void* __ptr, auto& __ctx, __format_spec::__parser<_CharT> __parser)
+    -> decltype(__ctx.out()) {
+  _LIBCPP_ASSERT(__parser.__alignment_ != __format_spec::__alignment::__default,
+                 "The call to parse should have updated the alignment");
+
+  __parser.__alternate_form_ = true;
+  __parser.__type_ = __format_spec::__type::__hexadecimal_lower_case;
+  return __format_integer(reinterpret_cast<uintptr_t>(__ptr), __ctx, __parser);
+}
+
+} // namespace __formatter
 
 template <__formatter::__char_type _CharT>
-class _LIBCPP_TEMPLATE_VIS __formatter_pointer : public __parser_pointer<_CharT> {
+struct _LIBCPP_TEMPLATE_VIS __formatter_pointer {
 public:
-  _LIBCPP_HIDE_FROM_ABI auto format(const void* __ptr, auto& __ctx) -> decltype(__ctx.out()) {
-    _LIBCPP_ASSERT(this->__alignment != _Flags::_Alignment::__default,
-                   "The call to parse should have updated the alignment");
-    if (this->__width_needs_substitution())
-      this->__substitute_width_arg_id(__ctx.arg(this->__width));
+  __formatter_pointer() { __parser_.__alignment_ = __format_spec::__alignment::__right; }
 
-    // This code looks a lot like the code to format a hexadecimal integral,
-    // but that code isn't public. Making that code public requires some
-    // refactoring.
-    // TODO FMT Remove code duplication.
-    char __buffer[2 + 2 * sizeof(uintptr_t)];
-    __buffer[0] = '0';
-    __buffer[1] = 'x';
-    char* __last = __to_buffer(__buffer + 2, _VSTD::end(__buffer), reinterpret_cast<uintptr_t>(__ptr), 16);
-
-    unsigned __size = __last - __buffer;
-    if (__size >= this->__width)
-      return _VSTD::copy(__buffer, __last, __ctx.out());
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    auto __result = __parser_.__parse(__parse_ctx, __format_spec::__fields_pointer);
+    __format_spec::__process_display_type_pointer(__parser_.__type_);
+    return __result;
+  }
 
-    return __formatter::__write(__ctx.out(), __buffer, __last, __size, this->__width, this->__fill, this->__alignment);
+  _LIBCPP_HIDE_FROM_ABI auto format(const void* __ptr, auto& __ctx) const -> decltype(__ctx.out()) {
+    return __formatter::__format_pointer(__ptr, __ctx, __parser_.__resolve_dynamic_sizes(__ctx));
   }
-};
 
-} // namespace __format_spec
+  __format_spec::__parser<_CharT> __parser_;
+};
 
 // [format.formatter.spec]/2.4
 // For each charT, the pointer type specializations template<>
 // - struct formatter<nullptr_t, charT>;
 // - template<> struct formatter<void*, charT>;
 // - template<> struct formatter<const void*, charT>;
 template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<nullptr_t, _CharT>
-    : public __format_spec::__formatter_pointer<_CharT> {};
+    : public __formatter_pointer<_CharT> {};
 template <__formatter::__char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<void*, _CharT>
-    : public __format_spec::__formatter_pointer<_CharT> {};
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<void*, _CharT> : public __formatter_pointer<_CharT> {
+};
 template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<const void*, _CharT>
-    : public __format_spec::__formatter_pointer<_CharT> {};
+    : public __formatter_pointer<_CharT> {};
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_FORMATTER_POINTER_H

libcxx/include/__format/formatter_string.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_STRING_H
 #define _LIBCPP___FORMAT_FORMATTER_STRING_H
 
-#include <__assert>
+#include <__availability>
 #include <__config>
-#include <__format/format_error.h>
 #include <__format/format_fwd.h>
-#include <__format/format_string.h>
+#include <__format/format_parse_context.h>
 #include <__format/formatter.h>
+#include <__format/formatter_output.h>
 #include <__format/parser_std_format_spec.h>
+#include <__utility/move.h>
+#include <string>
 #include <string_view>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
-namespace __format_spec {
+namespace __formatter {
 
-template <__formatter::__char_type _CharT>
-class _LIBCPP_TEMPLATE_VIS __formatter_string : public __parser_string<_CharT> {
-public:
-  _LIBCPP_HIDE_FROM_ABI auto format(basic_string_view<_CharT> __str,
-                                    auto& __ctx) -> decltype(__ctx.out()) {
-
-    _LIBCPP_ASSERT(this->__alignment != _Flags::_Alignment::__default,
-                   "The parser should not use these defaults");
-
-    if (this->__width_needs_substitution())
-      this->__substitute_width_arg_id(__ctx.arg(this->__width));
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI auto __format_string(basic_string_view<_CharT> __str,
+                                           output_iterator<const _CharT&> auto __out_it,
+                                           __format_spec::__parser<_CharT> __parser) -> decltype(__out_it) {
+  return __formatter::__write_unicode(__str, _VSTD::move(__out_it), __parser);
+}
 
-    if (this->__precision_needs_substitution())
-      this->__substitute_precision_arg_id(__ctx.arg(this->__precision));
+} // namespace __formatter
 
-    return __formatter::__write_unicode(
-        __ctx.out(), __str, this->__width,
-        this->__has_precision_field() ? this->__precision : -1, this->__fill,
-        this->__alignment);
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS __formatter_string {
+public:
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    auto __result = __parser_.__parse(__parse_ctx, __format_spec::__fields_string);
+    __format_spec::__process_display_type_string(__parser_.__type_);
+    return __result;
   }
-};
 
-} //namespace __format_spec
+  _LIBCPP_HIDE_FROM_ABI auto format(basic_string_view<_CharT> __str, auto& __ctx) const -> decltype(__ctx.out()) {
+    return __formatter::__format_string(__str, __ctx.out(), __parser_.__resolve_dynamic_sizes(__ctx));
+  }
 
-// [format.formatter.spec]/2.2 For each charT, the string type specializations
+  __format_spec::__parser<_CharT> __parser_;
+};
 
-// Formatter const char*.
 template <__formatter::__char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
-    formatter<const _CharT*, _CharT>
-    : public __format_spec::__formatter_string<_CharT> {
-  using _Base = __format_spec::__formatter_string<_CharT>;
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<const _CharT*, _CharT>
+    : public __formatter_string<_CharT> {
+  using _Base = __formatter_string<_CharT>;
 
-  _LIBCPP_HIDE_FROM_ABI auto format(const _CharT* __str, auto& __ctx)
-      -> decltype(__ctx.out()) {
+  // XXX const qualify
+  _LIBCPP_HIDE_FROM_ABI auto format(const _CharT* __str, auto& __ctx) const -> decltype(__ctx.out()) {
     _LIBCPP_ASSERT(__str, "The basic_format_arg constructor should have "
                           "prevented an invalid pointer.");
 
     // When using a center or right alignment and the width option the length
     // of __str must be known to add the padding upfront. This case is handled
     // by the base class by converting the argument to a basic_string_view.
     //
     // When using left alignment and the width option the padding is added
     // after outputting __str so the length can be determined while outputting
     // __str. The same holds true for the precision, during outputting __str it
     // can be validated whether the precision threshold has been reached. For
     // now these optimizations aren't implemented. Instead the base class
     // handles these options.
     // TODO FMT Implement these improvements.
-    if (this->__has_width_field() || this->__has_precision_field())
-      return _Base::format(__str, __ctx);
+    if (_Base::__parser_.__width_as_arg_ || _Base::__parser_.__precision_as_arg_ || //
+        _Base::__parser_.__has_width() || _Base::__parser_.__has_precision())
+      return _Base::format(basic_string_view<_CharT>(__str), __ctx);
 
     // No formatting required, copy the string to the output.
     auto __out_it = __ctx.out();
     while (*__str)
       *__out_it++ = *__str++;
     return __out_it;
   }
 };
 
 // Formatter char*.
 template <__formatter::__char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
-    formatter<_CharT*, _CharT> : public formatter<const _CharT*, _CharT> {
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<_CharT*, _CharT>
+    : public formatter<const _CharT*, _CharT> {
   using _Base = formatter<const _CharT*, _CharT>;
 
-  _LIBCPP_HIDE_FROM_ABI auto format(_CharT* __str, auto& __ctx)
-      -> decltype(__ctx.out()) {
+  _LIBCPP_HIDE_FROM_ABI auto format(_CharT* __str, auto& __ctx) const -> decltype(__ctx.out()) {
     return _Base::format(__str, __ctx);
   }
 };
 
 // Formatter const char[].
 template <__formatter::__char_type _CharT, size_t _Size>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
-    formatter<const _CharT[_Size], _CharT>
-    : public __format_spec::__formatter_string<_CharT> {
-  using _Base = __format_spec::__formatter_string<_CharT>;
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<const _CharT[_Size], _CharT>
+    : public __formatter_string<_CharT> {
+  using _Base = __formatter_string<_CharT>;
 
-  _LIBCPP_HIDE_FROM_ABI auto format(const _CharT __str[_Size], auto& __ctx)
-      -> decltype(__ctx.out()) {
+  _LIBCPP_HIDE_FROM_ABI auto format(const _CharT __str[_Size], auto& __ctx) const -> decltype(__ctx.out()) {
     return _Base::format(basic_string_view<_CharT>(__str, _Size), __ctx);
   }
 };
 
 // Formatter std::string.
 template <__formatter::__char_type _CharT, class _Traits, class _Allocator>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
-    formatter<basic_string<_CharT, _Traits, _Allocator>, _CharT>
-    : public __format_spec::__formatter_string<_CharT> {
-  using _Base = __format_spec::__formatter_string<_CharT>;
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<basic_string<_CharT, _Traits, _Allocator>, _CharT>
+    : public __formatter_string<_CharT> {
+  using _Base = __formatter_string<_CharT>;
 
-  _LIBCPP_HIDE_FROM_ABI auto
-  format(const basic_string<_CharT, _Traits, _Allocator>& __str, auto& __ctx)
+  _LIBCPP_HIDE_FROM_ABI auto format(const basic_string<_CharT, _Traits, _Allocator>& __str, auto& __ctx) const
       -> decltype(__ctx.out()) {
     // drop _Traits and _Allocator
     return _Base::format(basic_string_view<_CharT>(__str.data(), __str.size()), __ctx);
   }
 };
 
 // Formatter std::string_view.
 template <__formatter::__char_type _CharT, class _Traits>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<basic_string_view<_CharT, _Traits>, _CharT>
-    : public __format_spec::__formatter_string<_CharT> {
-  using _Base = __format_spec::__formatter_string<_CharT>;
+    : public __formatter_string<_CharT> {
+  using _Base = __formatter_string<_CharT>;
 
-  _LIBCPP_HIDE_FROM_ABI auto
-  format(basic_string_view<_CharT, _Traits> __str, auto& __ctx)
+  _LIBCPP_HIDE_FROM_ABI auto format(basic_string_view<_CharT, _Traits> __str, auto& __ctx) const
       -> decltype(__ctx.out()) {
     // drop _Traits
     return _Base::format(basic_string_view<_CharT>(__str.data(), __str.size()), __ctx);
   }
 };
 
+
+
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_FORMATTER_STRING_H

libcxx/include/__format/parser_std_format_spec.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_PARSER_STD_FORMAT_SPEC_H
 #define _LIBCPP___FORMAT_PARSER_STD_FORMAT_SPEC_H
 
+/// \file Contains the std-format-spec parser.
+///
+/// Most of the code can be reused in the chrono-format-spec.
+/// This header has some support for the chrono-format-spec since it doesn't
+/// affect the std-format-spec.
+
 #include <__algorithm/find_if.h>
 #include <__algorithm/min.h>
-#include <__assert>
 #include <__config>
+#include <__debug>
 #include <__format/format_arg.h>
 #include <__format/format_error.h>
+#include <__format/format_parse_context.h>
 #include <__format/format_string.h>
 #include <__variant/monostate.h>
 #include <bit>
 #include <concepts>
 #include <cstdint>
 #include <type_traits>
 
 #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
 
 namespace __format_spec {
 
-/**
- * Contains the flags for the std-format-spec.
- *
- * Some format-options can only be used for specific C++ types and may depend on
- * the selected format-type.
- * * The C++type filtering can be done using the proper policies for
- *   @ref __parser_std.
- * * The format-type filtering needs to be done post parsing in the parser
- *   derived from @ref __parser_std.
- */
-_LIBCPP_PACKED_BYTE_FOR_AIX
-class _LIBCPP_TYPE_VIS _Flags {
-public:
-  enum class _LIBCPP_ENUM_VIS _Alignment : uint8_t {
-    /**
-     * No alignment is set in the format string.
-     *
-     * Zero-padding is ignored when an alignment is selected.
-     * The default alignment depends on the selected format-type.
-     */
-    __default,
-    __left,
-    __center,
-    __right
-  };
-  enum class _LIBCPP_ENUM_VIS _Sign : uint8_t {
-    /**
-     * No sign is set in the format string.
-     *
-     * The sign isn't allowed for certain format-types. By using this value
-     * it's possible to detect whether or not the user explicitly set the sign
-     * flag. For formatting purposes it behaves the same as @ref __minus.
-     */
-    __default,
-    __minus,
-    __plus,
-    __space
-  };
+/// These fields are a filter for which elements to parse.
+///
+/// They default to false so when a new field is added it needs to be opted in
+/// explicitly. That way the behaviour of user-defined formatters won't change.
+///
+/// @note Since this stuct is part of the ABI it might be good to reserver some
+/// unreserved space.
+///
+/// @note Type bool or unspecified allowing bit-fields?
+struct __fields {
+  uint8_t __sign_ : 1 {false};
+  uint8_t __alternate_form_ : 1 {false};
+  uint8_t __zero_padding_ : 1 {false};
+  uint8_t __precision_ : 1 {false};
+  uint8_t __locale_specific_form_ : 1 {false};
+  // This field is special it's always true for the std-format-spec.
+  // Since the chrono-format-spec doesn't use this field it can be disabled.
+  uint8_t __type_ : 1 {true};
+};
+
+// By not placing this constant in the formatter class it's not duplicated for char and wchar_t
+inline constexpr __fields __fields_integral{
+    .__sign_ = true, .__alternate_form_ = true, .__zero_padding_ = true, .__locale_specific_form_ = true};
+inline constexpr __fields __fields_floating_point{
+    .__sign_ = true,
+    .__alternate_form_ = true,
+    .__zero_padding_ = true,
+    .__precision_ = true,
+    .__locale_specific_form_ = true,
+};
+inline constexpr __fields __fields_string{
+    .__precision_ = true,
+};
+inline constexpr __fields __fields_pointer{};
+
+enum class _LIBCPP_ENUM_VIS __alignment : uint8_t {
+  /// No alignment is set in the format string.
+  ///
+  /// Zero-padding is ignored when an alignment is selected.
+  /// The default alignment depends on the selected format-type.
+
+enum class _LIBCPP_ENUM_VIS __sign : uint8_t {
+  /// No sign is set in the format string.
+  ///
+  /// The sign isn't allowed for certain format-types. By using this value
+  /// it's possible to detect whether or not the user explicitly set the sign
+  /// flag. For formatting purposes it behaves the same as @ref __minus.
 
-  _Alignment __alignment : 2 {_Alignment::__default};
-  _Sign __sign : 2 {_Sign::__default};
-  uint8_t __alternate_form : 1 {false};
-  uint8_t __zero_padding : 1 {false};
-  uint8_t __locale_specific_form : 1 {false};
-
-  enum class _LIBCPP_ENUM_VIS _Type : uint8_t {
-    __default,
-    __string,
-    __binary_lower_case,
-    __binary_upper_case,
-    __octal,
-    __decimal,
-    __hexadecimal_lower_case,
-    __hexadecimal_upper_case,
-    __pointer,
-    __char,
-    __float_hexadecimal_lower_case,
-    __float_hexadecimal_upper_case,
-    __scientific_lower_case,
-    __scientific_upper_case,
-    __fixed_lower_case,
-    __fixed_upper_case,
-    __general_lower_case,
-    __general_upper_case
-  };
+enum class _LIBCPP_ENUM_VIS __type : uint8_t {
 
-  _Type __type{_Type::__default};
-};
-_LIBCPP_PACKED_BYTE_FOR_AIX_END
-
-namespace __detail {
-template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI constexpr bool
-__parse_alignment(_CharT __c, _Flags& __flags) noexcept {
-  switch (__c) {
-  case _CharT('<'):
-    __flags.__alignment = _Flags::_Alignment::__left;
-    return true;
-
-  case _CharT('^'):
-    __flags.__alignment = _Flags::_Alignment::__center;
-    return true;
-
-  case _CharT('>'):
-    __flags.__alignment = _Flags::_Alignment::__right;
-    return true;
-  }
-  return false;
-}
-} // namespace __detail
-
-template <class _CharT>
-class _LIBCPP_TEMPLATE_VIS __parser_fill_align {
-public:
-  // TODO FMT The standard doesn't specify this character is a Unicode
-  // character. Validate what fmt and MSVC have implemented.
-  _CharT __fill{_CharT(' ')};
-
-protected:
-  _LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
-  __parse(const _CharT* __begin, const _CharT* __end, _Flags& __flags) {
-    _LIBCPP_ASSERT(__begin != __end,
-                   "When called with an empty input the function will cause "
-                   "undefined behavior by evaluating data not in the input");
-    if (__begin + 1 != __end) {
-      if (__detail::__parse_alignment(*(__begin + 1), __flags)) {
-        if (*__begin == _CharT('{') || *__begin == _CharT('}'))
-          __throw_format_error(
-              "The format-spec fill field contains an invalid character");
-        __fill = *__begin;
-        return __begin + 2;
-      }
-    }
-
-    if (__detail::__parse_alignment(*__begin, __flags))
-      return __begin + 1;
-
-    return __begin;
-  }
-};
-
-template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
-__parse_sign(const _CharT* __begin, _Flags& __flags) noexcept {
-  switch (*__begin) {
-  case _CharT('-'):
-    __flags.__sign = _Flags::_Sign::__minus;
-    break;
-  case _CharT('+'):
-    __flags.__sign = _Flags::_Sign::__plus;
-    break;
-  case _CharT(' '):
-    __flags.__sign = _Flags::_Sign::__space;
-    break;
-  default:
-    return __begin;
-  }
-  return __begin + 1;
-}
-
-template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
-__parse_alternate_form(const _CharT* __begin, _Flags& __flags) noexcept {
-  if (*__begin == _CharT('#')) {
-    __flags.__alternate_form = true;
-    ++__begin;
-  }
-
-  return __begin;
-}
-
-template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
-__parse_zero_padding(const _CharT* __begin, _Flags& __flags) noexcept {
-  if (*__begin == _CharT('0')) {
-    __flags.__zero_padding = true;
-    ++__begin;
-  }
-
-  return __begin;
-}
-
 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI constexpr __format::__parse_number_result< _CharT>
 __parse_arg_id(const _CharT* __begin, const _CharT* __end, auto& __parse_ctx) {
   // This function is a wrapper to call the real parser. But it does the
   // validation for the pre-conditions and post-conditions.
   if (__begin == __end)
     __throw_format_error("End of input while parsing format-spec arg-id");
 
   __format::__parse_number_result __r =
       __format::__parse_arg_id(__begin, __end, __parse_ctx);
 
   if (__r.__ptr == __end || *__r.__ptr != _CharT('}'))
     __throw_format_error("Invalid arg-id");
 
   ++__r.__ptr;
   return __r;
 }
 
 template <class _Context>
 _LIBCPP_HIDE_FROM_ABI constexpr uint32_t
-__substitute_arg_id(basic_format_arg<_Context> _Arg) {
+__substitute_arg_id(basic_format_arg<_Context> __arg) {
   return visit_format_arg(
-      [](auto __arg) -> uint32_t {
-        using _Type = decltype(__arg);
+      [](auto __value) -> uint32_t {
+        using _Type = decltype(__value);
         if constexpr (integral<_Type>) {
           if constexpr (signed_integral<_Type>) {
-            if (__arg < 0)
+            if (__value < 0)
               __throw_format_error("A format-spec arg-id replacement shouldn't "
                                    "have a negative value");
           }
 
           using _CT = common_type_t<_Type, decltype(__format::__number_max)>;
-          if (static_cast<_CT>(__arg) >
-              static_cast<_CT>(__format::__number_max))
+          if (static_cast<_CT>(__value) > static_cast<_CT>(__format::__number_max))
             __throw_format_error("A format-spec arg-id replacement exceeds "
                                  "the maximum supported value");
 
-          return __arg;
+          return __value;
         } else if constexpr (same_as<_Type, monostate>)
           __throw_format_error("Argument index out of bounds");
         else
           __throw_format_error("A format-spec arg-id replacement argument "
                                "isn't an integral type");
       },
-      _Arg);
+      __arg);
 }
 
-class _LIBCPP_TYPE_VIS __parser_width {
+template <class _CharT>
+class _LIBCPP_TEMPLATE_VIS __parser {
 public:
-  /** Contains a width or an arg-id. */
-  uint32_t __width : 31 {0};
-  /** Determines whether the value stored is a width or an arg-id. */
-  uint32_t __width_as_arg : 1 {0};
+  _LIBCPP_HIDE_FROM_ABI constexpr auto __parse(basic_format_parse_context<_CharT>& __parse_ctx, __fields __fields)
+      -> decltype(__parse_ctx.begin()) {
 
-protected:
-  /**
-   * Does the supplied std-format-spec contain a width field?
-   *
-   * When the field isn't present there's no padding required. This can be used
-   * to optimize the formatting.
-   */
-  constexpr bool __has_width_field() const noexcept {
-    return __width_as_arg || __width;
+    const _CharT* __begin = __parse_ctx.begin();
+    const _CharT* __end = __parse_ctx.end();
+    if (__begin == __end)
+      return __begin;
+
+    if (__parse_fill_align(__begin, __end) && __begin == __end)
+      return __begin;
+
+    if (__fields.__sign_ && __parse_sign(__begin) && __begin == __end)
+      return __begin;
+
+    if (__fields.__alternate_form_ && __parse_alternate_form(__begin) && __begin == __end)
+      return __begin;
+
+    if (__fields.__zero_padding_ && __parse_zero_padding(__begin) && __begin == __end)
+      return __begin;
+
+    if (__parse_width(__begin, __end, __parse_ctx) && __begin == __end)
+      return __begin;
+
+    if (__fields.__precision_ && __parse_precision(__begin, __end, __parse_ctx) && __begin == __end)
+      return __begin;
+
+    if (__fields.__locale_specific_form_ && __parse_locale_specific_form(__begin) && __begin == __end)
+      return __begin;
+
+    if (__fields.__type_) {
+      __parse_type(__begin);
+
+      if (__begin != __end && *__begin != _CharT('}'))
+        __throw_format_error("The format-spec should consume the input or end with a '}'");
     }
 
-  /**
-   * Does the supplied width field contain an arg-id?
-   *
-   * If @c true the formatter needs to call @ref __substitute_width_arg_id.
-   */
-  constexpr bool __width_needs_substitution() const noexcept {
-    return __width_as_arg;
+    return __begin;
   }
 
-  template <class _CharT>
-  _LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
-  __parse(const _CharT* __begin, const _CharT* __end, auto& __parse_ctx) {
-    if (*__begin == _CharT('0'))
-      __throw_format_error(
-          "A format-spec width field shouldn't have a leading zero");
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __has_width() const {
+    _LIBCPP_ASSERT(!__width_as_arg_, "the function should only be used to test __width_");
+    return __width_ > 0;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __has_precision() const {
+    _LIBCPP_ASSERT(!__precision_as_arg_, "the function should only be used to test __precision_");
+    return __precision_ >= 0;
+  }
+
+  /// \returns a copy of the parser with the resolved dynamic sizes.
+  ///
+  /// Returning a copy makes it possible to create a const qualified format
+  /// member function. The parser is cheap to copy.
+  _LIBCPP_HIDE_FROM_ABI
+  __parser __resolve_dynamic_sizes(auto& __ctx) const {
+    __parser __result{*this};
+
+    if (__result.__width_as_arg_)
+      __result.__substitute_width_arg_id(__ctx.arg(__result.__width_));
+
+    if (__result.__precision_as_arg_)
+      __result.__substitute_precision_arg_id(__ctx.arg(__result.__precision_));
+
+    return __result;
+  }
+
+  __alignment __alignment_ : 2 {__alignment::__default};
+  __sign __sign_ : 2 {__sign::__default};
+  uint8_t __alternate_form_ : 1 {false};
+  uint8_t __zero_padding_ : 1 {false};
+  uint8_t __locale_specific_form_ : 1 {false};
+  __type __type_ : 5 {__type::__default};
+
+  uint8_t __width_as_arg_ : 1 {false};
+  uint8_t __precision_as_arg_ : 1 {false};
+
+  // These two flags are used for formatting chrono. Since the struct has
+  // padding space left it's added to this structure.
+  uint8_t __weekday_name_ : 1 {false};
+  uint8_t __month_name_ : 1 {false};
+  // LWG 3576 will probably change this to always accept a Unicode code point
+  // To avoid changing the size with that change align the field so when it
+  // becomes 32-bit its alignment will remain the same. That also means the
+  // size will remain the same. (D2572 addresses the solution for LWG 3576.)
+  alignas(4) _CharT __fill_{_CharT(' ')};
+  int32_t __width_{0};
+  int32_t __precision_{-1};
 
-    if (*__begin == _CharT('{')) {
-      __format::__parse_number_result __r =
-          __parse_arg_id(++__begin, __end, __parse_ctx);
-      __width = __r.__value;
-      __width_as_arg = 1;
-      return __r.__ptr;
-    }
+private:
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_alignment(_CharT __c) {
+    switch (__c) {
+    case _CharT('<'):
+      __alignment_ = __alignment::__left;
+      return true;
+
+    case _CharT('^'):
+      __alignment_ = __alignment::__center;
+      return true;
+
+    case _CharT('>'):
+      __alignment_ = __alignment::__right;
+      return true;
+    }
+    return false;
 
-    if (*__begin < _CharT('0') || *__begin > _CharT('9'))
-      return __begin;
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_fill_align(const _CharT*& __begin, const _CharT* __end) {
+    _LIBCPP_ASSERT(__begin != __end, "when called with an empty input the function will cause "
+                                     "undefined behavior by evaluating data not in the input");
+    if (__begin + 1 != __end) {
+      if (__parse_alignment(*(__begin + 1))) {
+        if (*__begin == _CharT('{') || *__begin == _CharT('}'))
+          __throw_format_error("The format-spec fill field contains an invalid character");
 
-    __format::__parse_number_result __r =
-        __format::__parse_number(__begin, __end);
-    __width = __r.__value;
-    _LIBCPP_ASSERT(__width != 0,
-                   "A zero value isn't allowed and should be impossible, "
-                   "due to validations in this function");
-    return __r.__ptr;
+        __fill_ = *__begin;
+        __begin += 2;
+        return true;
+      }
     }
 
-  _LIBCPP_HIDE_FROM_ABI constexpr void __substitute_width_arg_id(auto __arg) {
-    _LIBCPP_ASSERT(__width_as_arg == 1,
-                   "Substitute width called when no substitution is required");
+    if (!__parse_alignment(*__begin))
+      return false;
 
-    // The clearing of the flag isn't required but looks better when debugging
-    // the code.
-    __width_as_arg = 0;
-    __width = __substitute_arg_id(__arg);
-    if (__width == 0)
-      __throw_format_error(
-          "A format-spec width field replacement should have a positive value");
+    ++__begin;
+    return true;
   }
-};
 
-class _LIBCPP_TYPE_VIS __parser_precision {
-public:
-  /** Contains a precision or an arg-id. */
-  uint32_t __precision : 31 {__format::__number_max};
-  /**
-   * Determines whether the value stored is a precision or an arg-id.
-   *
-   * @note Since @ref __precision == @ref __format::__number_max is a valid
-   * value, the default value contains an arg-id of INT32_MAX. (This number of
-   * arguments isn't supported by compilers.)  This is used to detect whether
-   * the std-format-spec contains a precision field.
-   */
-  uint32_t __precision_as_arg : 1 {1};
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_sign(const _CharT*& __begin) {
+    switch (*__begin) {
+    case _CharT('-'):
+      __sign_ = __sign::__minus;
+      break;
+    case _CharT('+'):
+      __sign_ = __sign::__plus;
+      break;
+    case _CharT(' '):
+      __sign_ = __sign::__space;
+      break;
+    default:
+      return false;
+    }
+    ++__begin;
+    return true;
+  }
 
-protected:
-  /**
-   * Does the supplied std-format-spec contain a precision field?
-   *
-   * When the field isn't present there's no truncating required. This can be
-   * used to optimize the formatting.
-   */
-  constexpr bool __has_precision_field() const noexcept {
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_alternate_form(const _CharT*& __begin) {
+    if (*__begin != _CharT('#'))
+      return false;
 
-    return __precision_as_arg == 0 ||             // Contains a value?
-           __precision != __format::__number_max; // The arg-id is valid?
+    __alternate_form_ = true;
+    ++__begin;
+    return true;
   }
 
-  /**
-   * Does the supplied precision field contain an arg-id?
-   *
-   * If @c true the formatter needs to call @ref __substitute_precision_arg_id.
-   */
-  constexpr bool __precision_needs_substitution() const noexcept {
-    return __precision_as_arg && __precision != __format::__number_max;
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_zero_padding(const _CharT*& __begin) {
+    if (*__begin != _CharT('0'))
+      return false;
+
+    __zero_padding_ = true;
+    ++__begin;
+    return true;
   }
 
-  template <class _CharT>
-  _LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
-  __parse(const _CharT* __begin, const _CharT* __end, auto& __parse_ctx) {
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_width(const _CharT*& __begin, const _CharT* __end, auto& __parse_ctx) {
+    if (*__begin == _CharT('0'))
+      __throw_format_error("A format-spec width field shouldn't have a leading zero");
+
+    if (*__begin == _CharT('{')) {
+      __format::__parse_number_result __r = __format_spec::__parse_arg_id(++__begin, __end, __parse_ctx);
+      __width_as_arg_ = true;
+      __width_ = __r.__value;
+      __begin = __r.__ptr;
+      return true;
+    }
+
+    if (*__begin < _CharT('0') || *__begin > _CharT('9'))
+      return false;
+
+    __format::__parse_number_result __r = __format::__parse_number(__begin, __end);
+    __width_ = __r.__value;
+    _LIBCPP_ASSERT(__width_ != 0, "A zero value isn't allowed and should be impossible, "
+                                  "due to validations in this function");
+    __begin = __r.__ptr;
+    return true;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_precision(const _CharT*& __begin, const _CharT* __end,
+                                                         auto& __parse_ctx) {
     if (*__begin != _CharT('.'))
-      return __begin;
+      return false;
 
     ++__begin;
     if (__begin == __end)
       __throw_format_error("End of input while parsing format-spec precision");
 
     if (*__begin == _CharT('{')) {
-      __format::__parse_number_result __arg_id =
-          __parse_arg_id(++__begin, __end, __parse_ctx);
-      _LIBCPP_ASSERT(__arg_id.__value != __format::__number_max,
-                     "Unsupported number of arguments, since this number of "
-                     "arguments is used a special value");
-      __precision = __arg_id.__value;
-      return __arg_id.__ptr;
+      __format::__parse_number_result __arg_id = __format_spec::__parse_arg_id(++__begin, __end, __parse_ctx);
+      __precision_as_arg_ = true;
+      __precision_ = __arg_id.__value;
+      __begin = __arg_id.__ptr;
+      return true;
     }
 
     if (*__begin < _CharT('0') || *__begin > _CharT('9'))
-      __throw_format_error(
-          "The format-spec precision field doesn't contain a value or arg-id");
+      __throw_format_error("The format-spec precision field doesn't contain a value or arg-id");
 
-    __format::__parse_number_result __r =
-        __format::__parse_number(__begin, __end);
-    __precision = __r.__value;
-    __precision_as_arg = 0;
-    return __r.__ptr;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr void __substitute_precision_arg_id(
-      auto __arg) {
-    _LIBCPP_ASSERT(
-        __precision_as_arg == 1 && __precision != __format::__number_max,
-        "Substitute precision called when no substitution is required");
-
-    // The clearing of the flag isn't required but looks better when debugging
-    // the code.
-    __precision_as_arg = 0;
-    __precision = __substitute_arg_id(__arg);
+    __format::__parse_number_result __r = __format::__parse_number(__begin, __end);
+    __precision_ = __r.__value;
+    __precision_as_arg_ = false;
+    __begin = __r.__ptr;
+    return true;
   }
-};
 
-template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
-__parse_locale_specific_form(const _CharT* __begin, _Flags& __flags) noexcept {
-  if (*__begin == _CharT('L')) {
-    __flags.__locale_specific_form = true;
-    ++__begin;
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_locale_specific_form(const _CharT*& __begin) {
+    if (*__begin != _CharT('L'))
+      return false;
 
-  return __begin;
+    __locale_specific_form_ = true;
+    ++__begin;
+    return true;
   }
 
-template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
-__parse_type(const _CharT* __begin, _Flags& __flags) {
-
+  _LIBCPP_HIDE_FROM_ABI constexpr void __parse_type(const _CharT*& __begin) {
     // Determines the type. It does not validate whether the selected type is
     // valid. Most formatters have optional fields that are only allowed for
     // certain types. These parsers need to do validation after the type has
     // been parsed. So its easier to implement the validation for all types in
     // the specific parse function.
     switch (*__begin) {
     case 'A':
-    __flags.__type = _Flags::_Type::__float_hexadecimal_upper_case;
+      __type_ = __type::__float_hexadecimal_upper_case;
       break;
     case 'B':
-    __flags.__type = _Flags::_Type::__binary_upper_case;
+      __type_ = __type::__binary_upper_case;
       break;
     case 'E':
-    __flags.__type = _Flags::_Type::__scientific_upper_case;
+      __type_ = __type::__scientific_upper_case;
       break;
     case 'F':
-    __flags.__type = _Flags::_Type::__fixed_upper_case;
+      __type_ = __type::__fixed_upper_case;
       break;
     case 'G':
-    __flags.__type = _Flags::_Type::__general_upper_case;
+      __type_ = __type::__general_upper_case;
       break;
     case 'X':
-    __flags.__type = _Flags::_Type::__hexadecimal_upper_case;
+      __type_ = __type::__hexadecimal_upper_case;
       break;
     case 'a':
-    __flags.__type = _Flags::_Type::__float_hexadecimal_lower_case;
+      __type_ = __type::__float_hexadecimal_lower_case;
       break;
     case 'b':
-    __flags.__type = _Flags::_Type::__binary_lower_case;
+      __type_ = __type::__binary_lower_case;
       break;
     case 'c':
-    __flags.__type = _Flags::_Type::__char;
+      __type_ = __type::__char;
       break;
     case 'd':
-    __flags.__type = _Flags::_Type::__decimal;
+      __type_ = __type::__decimal;
       break;
     case 'e':
-    __flags.__type = _Flags::_Type::__scientific_lower_case;
+      __type_ = __type::__scientific_lower_case;
       break;
     case 'f':
-    __flags.__type = _Flags::_Type::__fixed_lower_case;
+      __type_ = __type::__fixed_lower_case;
       break;
     case 'g':
-    __flags.__type = _Flags::_Type::__general_lower_case;
+      __type_ = __type::__general_lower_case;
       break;
     case 'o':
-    __flags.__type = _Flags::_Type::__octal;
+      __type_ = __type::__octal;
       break;
     case 'p':
-    __flags.__type = _Flags::_Type::__pointer;
+      __type_ = __type::__pointer;
       break;
     case 's':
-    __flags.__type = _Flags::_Type::__string;
+      __type_ = __type::__string;
       break;
     case 'x':
-    __flags.__type = _Flags::_Type::__hexadecimal_lower_case;
+      __type_ = __type::__hexadecimal_lower_case;
       break;
     default:
-    return __begin;
-  }
-  return ++__begin;
+      return;
     }
-
-/**
- * Process the parsed alignment and zero-padding state of arithmetic types.
- *
- * [format.string.std]/13
- *   If the 0 character and an align option both appear, the 0 character is
- *   ignored.
- *
- * For the formatter a @ref __default alignment means zero-padding.
- */
-_LIBCPP_HIDE_FROM_ABI constexpr void __process_arithmetic_alignment(_Flags& __flags) {
-  __flags.__zero_padding &= __flags.__alignment == _Flags::_Alignment::__default;
-  if (!__flags.__zero_padding && __flags.__alignment == _Flags::_Alignment::__default)
-    __flags.__alignment = _Flags::_Alignment::__right;
+    ++__begin;
   }
 
-/**
- * The parser for the std-format-spec.
- *
- * [format.string.std]/1 specifies the std-format-spec:
- *   fill-and-align sign # 0 width precision L type
- *
- * All these fields are optional. Whether these fields can be used depend on:
- * - The type supplied to the format string.
- *   E.g. A string never uses the sign field so the field may not be set.
- *   This constrain is validated by the parsers in this file.
- * - The supplied value for the optional type field.
- *   E.g. A int formatted as decimal uses the sign field.
- *   When formatted as a char the sign field may no longer be set.
- *   This constrain isn't validated by the parsers in this file.
- *
- * The base classes are ordered to minimize the amount of padding.
- *
- * This implements the parser for the string types.
- */
-template <class _CharT>
-class _LIBCPP_TEMPLATE_VIS __parser_string
-    : public __parser_width,              // provides __width(|as_arg)
-      public __parser_precision,          // provides __precision(|as_arg)
-      public __parser_fill_align<_CharT>, // provides __fill and uses __flags
-      public _Flags                       // provides __flags
-{
-public:
-  using char_type = _CharT;
-
-  _LIBCPP_HIDE_FROM_ABI constexpr __parser_string() {
-    this->__alignment = _Flags::_Alignment::__left;
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr void __substitute_width_arg_id(auto __arg) {
+    _LIBCPP_ASSERT(__width_as_arg_ == true, "Substitute width called when no substitution is required");
 
-  /**
-   * The low-level std-format-spec parse function.
-   *
-   * @pre __begin points at the beginning of the std-format-spec. This means
-   * directly after the ':'.
-   * @pre The std-format-spec parses the entire input, or the first unmatched
-   * character is a '}'.
-   *
-   * @returns The iterator pointing at the last parsed character.
-   */
-  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(auto& __parse_ctx)
-      -> decltype(__parse_ctx.begin()) {
-    auto __it = __parse(__parse_ctx);
-    __process_display_type();
-    return __it;
+    __width_as_arg_ = 0;
+    __width_ = __format_spec::__substitute_arg_id(__arg);
+    if (__width_ == 0)
+      __throw_format_error("A format-spec width field replacement should have a positive value");
   }
 
-private:
-  /**
-   * Parses the std-format-spec.
-   *
-   * @throws __throw_format_error When @a __parse_ctx contains an ill-formed
-   *                               std-format-spec.
-   *
-   * @returns An iterator to the end of input or point at the closing '}'.
-   */
-  _LIBCPP_HIDE_FROM_ABI constexpr auto __parse(auto& __parse_ctx)
-      -> decltype(__parse_ctx.begin()) {
-
-    auto __begin = __parse_ctx.begin();
-    auto __end = __parse_ctx.end();
-    if (__begin == __end)
-      return __begin;
-
-    __begin = __parser_fill_align<_CharT>::__parse(__begin, __end,
-                                                   static_cast<_Flags&>(*this));
-    if (__begin == __end)
-      return __begin;
-
-    __begin = __parser_width::__parse(__begin, __end, __parse_ctx);
-    if (__begin == __end)
-      return __begin;
+  _LIBCPP_HIDE_FROM_ABI constexpr void __substitute_precision_arg_id(auto __arg) {
+    _LIBCPP_ASSERT(__precision_as_arg_ == true, "Substitute width called when no substitution is required");
 
-    __begin = __parser_precision::__parse(__begin, __end, __parse_ctx);
-    if (__begin == __end)
-      return __begin;
-
-    __begin = __parse_type(__begin, static_cast<_Flags&>(*this));
-
-    if (__begin != __end && *__begin != _CharT('}'))
-      __throw_format_error(
-          "The format-spec should consume the input or end with a '}'");
-
-    return __begin;
+    __precision_as_arg_ = false;
+    __precision_ = __format_spec::__substitute_arg_id(__arg);
   }
+};
 
-  /** Processes the parsed std-format-spec based on the parsed display type. */
-  _LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type() {
-    switch (this->__type) {
-    case _Flags::_Type::__default:
-    case _Flags::_Type::__string:
-      break;
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_string(__format_spec::__type __type) {
+  switch (__type) {
+  case __format_spec::__type::__default:
+  case __format_spec::__type::__string:
 
-    default:
-      __throw_format_error("The format-spec type has a type not supported for "
-                           "a string argument");
-    }
-  }
-};
 
-/**
- * The parser for the std-format-spec.
- *
- * This implements the parser for the integral types. This includes the
- * character type and boolean type.
- *
- * See @ref __parser_string.
- */
 template <class _CharT>
-class _LIBCPP_TEMPLATE_VIS __parser_integral
-    : public __parser_width,              // provides __width(|as_arg)
-      public __parser_fill_align<_CharT>, // provides __fill and uses __flags
-      public _Flags                       // provides __flags
-{
-public:
-  using char_type = _CharT;
-
-protected:
-  /**
-   * The low-level std-format-spec parse function.
-   *
-   * @pre __begin points at the beginning of the std-format-spec. This means
-   * directly after the ':'.
-   * @pre The std-format-spec parses the entire input, or the first unmatched
-   * character is a '}'.
-   *
-   * @returns The iterator pointing at the last parsed character.
-   */
-  _LIBCPP_HIDE_FROM_ABI constexpr auto __parse(auto& __parse_ctx)
-      -> decltype(__parse_ctx.begin()) {
-    auto __begin = __parse_ctx.begin();
-    auto __end = __parse_ctx.end();
-    if (__begin == __end)
-      return __begin;
-
-    __begin = __parser_fill_align<_CharT>::__parse(__begin, __end,
-                                                   static_cast<_Flags&>(*this));
-    if (__begin == __end)
-      return __begin;
-
-    __begin = __parse_sign(__begin, static_cast<_Flags&>(*this));
-    if (__begin == __end)
-      return __begin;
-
-    __begin = __parse_alternate_form(__begin, static_cast<_Flags&>(*this));
-    if (__begin == __end)
-      return __begin;
-
-    __begin = __parse_zero_padding(__begin, static_cast<_Flags&>(*this));
-    if (__begin == __end)
-      return __begin;
-
-    __begin = __parser_width::__parse(__begin, __end, __parse_ctx);
-    if (__begin == __end)
-      return __begin;
-
-    __begin =
-        __parse_locale_specific_form(__begin, static_cast<_Flags&>(*this));
-    if (__begin == __end)
-      return __begin;
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_bool_string(__parser<_CharT>& __parser) {
+  if (__parser.__sign_ != __sign::__default)
+    __throw_format_error("A sign field isn't allowed in this format-spec");
 
-    __begin = __parse_type(__begin, static_cast<_Flags&>(*this));
+  if (__parser.__alternate_form_)
+    __throw_format_error("An alternate form field isn't allowed in this format-spec");
 
-    if (__begin != __end && *__begin != _CharT('}'))
-      __throw_format_error(
-          "The format-spec should consume the input or end with a '}'");
+  if (__parser.__zero_padding_)
+    __throw_format_error("A zero-padding field isn't allowed in this format-spec");
 
-    return __begin;
-  }
+  if (__parser.__alignment_ == __alignment::__default)
+    __parser.__alignment_ = __alignment::__left;
 
-  /** Handles the post-parsing updates for the integer types. */
-  _LIBCPP_HIDE_FROM_ABI constexpr void __handle_integer() noexcept {
-    __process_arithmetic_alignment(static_cast<_Flags&>(*this));
-  }
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_char(__parser<_CharT>& __parser) {
+  __process_display_type_bool_string(__parser);
 
-  /**
-   * Handles the post-parsing updates for the character types.
-   *
-   * Sets the alignment and validates the format flags set for a character type.
-   *
-   * At the moment the validation for a character and a Boolean behave the
-   * same, but this may change in the future.
-   * Specifically at the moment the locale-specific form is allowed for the
-   * char output type, but it has no effect on the output.
-   */
-  _LIBCPP_HIDE_FROM_ABI constexpr void __handle_char() { __handle_bool(); }
-
-  /**
-   * Handles the post-parsing updates for the Boolean types.
-   *
-   * Sets the alignment and validates the format flags set for a Boolean type.
-   */
-  _LIBCPP_HIDE_FROM_ABI constexpr void __handle_bool() {
-    if (this->__sign != _Flags::_Sign::__default)
-      __throw_format_error("A sign field isn't allowed in this format-spec");
-
-    if (this->__alternate_form)
-      __throw_format_error(
-          "An alternate form field isn't allowed in this format-spec");
-
-    if (this->__zero_padding)
-      __throw_format_error(
-          "A zero-padding field isn't allowed in this format-spec");
-
-    if (this->__alignment == _Flags::_Alignment::__default)
-      this->__alignment = _Flags::_Alignment::__left;
-  }
-};
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI constexpr void __resolve_zero_padding(__parser<_CharT>& __parser) {
+  __parser.__zero_padding_ &= __parser.__alignment_ == __alignment::__default;
+  if (!__parser.__zero_padding_ && __parser.__alignment_ == __alignment::__default)
+    __parser.__alignment_ = __alignment::__right;
 
-/**
- * The parser for the std-format-spec.
- *
- * This implements the parser for the floating-point types.
- *
- * See @ref __parser_string.
- */
 template <class _CharT>
-class _LIBCPP_TEMPLATE_VIS __parser_floating_point
-    : public __parser_width,              // provides __width(|as_arg)
-      public __parser_precision,          // provides __precision(|as_arg)
-      public __parser_fill_align<_CharT>, // provides __fill and uses __flags
-      public _Flags                       // provides __flags
-{
-public:
-  using char_type = _CharT;
-
-  /**
-   * The low-level std-format-spec parse function.
-   *
-   * @pre __begin points at the beginning of the std-format-spec. This means
-   * directly after the ':'.
-   * @pre The std-format-spec parses the entire input, or the first unmatched
-   * character is a '}'.
-   *
-   * @returns The iterator pointing at the last parsed character.
-   */
-  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(auto& __parse_ctx)
-      -> decltype(__parse_ctx.begin()) {
-    auto __it = __parse(__parse_ctx);
-    __process_arithmetic_alignment(static_cast<_Flags&>(*this));
-    __process_display_type();
-    return __it;
-  }
-protected:
-  /**
-   * The low-level std-format-spec parse function.
-   *
-   * @pre __begin points at the beginning of the std-format-spec. This means
-   * directly after the ':'.
-   * @pre The std-format-spec parses the entire input, or the first unmatched
-   * character is a '}'.
-   *
-   * @returns The iterator pointing at the last parsed character.
-   */
-  _LIBCPP_HIDE_FROM_ABI constexpr auto __parse(auto& __parse_ctx)
-      -> decltype(__parse_ctx.begin()) {
-    auto __begin = __parse_ctx.begin();
-    auto __end = __parse_ctx.end();
-    if (__begin == __end)
-      return __begin;
-
-    __begin = __parser_fill_align<_CharT>::__parse(__begin, __end,
-                                                   static_cast<_Flags&>(*this));
-    if (__begin == __end)
-      return __begin;
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_integer(__parser<_CharT>& __parser) {
+  __resolve_zero_padding(__parser);
 
-    __begin = __parse_sign(__begin, static_cast<_Flags&>(*this));
-    if (__begin == __end)
-      return __begin;
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_bool(__parser<_CharT>& __parser) {
+  switch (__parser.__type_) {
+  case __format_spec::__type::__default:
+    __parser.__type_ = __format_spec::__type::__string;
+    [[fallthrough]];
+  case __format_spec::__type::__string:
+    __process_display_type_bool_string(__parser);
+    break;
 
-    __begin = __parse_alternate_form(__begin, static_cast<_Flags&>(*this));
-    if (__begin == __end)
-      return __begin;
+  case __format_spec::__type::__binary_lower_case:
+  case __format_spec::__type::__binary_upper_case:
+  case __format_spec::__type::__octal:
+  case __format_spec::__type::__decimal:
+  case __format_spec::__type::__hexadecimal_lower_case:
+  case __format_spec::__type::__hexadecimal_upper_case:
+    __process_display_type_integer(__parser);
+    break;
 
-    __begin = __parse_zero_padding(__begin, static_cast<_Flags&>(*this));
-    if (__begin == __end)
-      return __begin;
+  default:
+    __throw_format_error("The format-spec type has a type not supported for a bool argument");
+  }
+}
 
-    __begin = __parser_width::__parse(__begin, __end, __parse_ctx);
-    if (__begin == __end)
-      return __begin;
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_char(__parser<_CharT>& __parser) {
+  switch (__parser.__type_) {
+  case __format_spec::__type::__default:
+    __parser.__type_ = __format_spec::__type::__char;
+    [[fallthrough]];
+  case __format_spec::__type::__char:
+    __process_display_type_char(__parser);
+    break;
 
-    __begin = __parser_precision::__parse(__begin, __end, __parse_ctx);
-    if (__begin == __end)
-      return __begin;
+  case __format_spec::__type::__binary_lower_case:
+  case __format_spec::__type::__binary_upper_case:
+  case __format_spec::__type::__octal:
+  case __format_spec::__type::__decimal:
+  case __format_spec::__type::__hexadecimal_lower_case:
+  case __format_spec::__type::__hexadecimal_upper_case:
+    __process_display_type_integer(__parser);
+    break;
 
-    __begin =
-        __parse_locale_specific_form(__begin, static_cast<_Flags&>(*this));
-    if (__begin == __end)
-      return __begin;
+  default:
+    __throw_format_error("The format-spec type has a type not supported for a char argument");
+  }
+}
 
-    __begin = __parse_type(__begin, static_cast<_Flags&>(*this));
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_integer(__parser<_CharT>& __parser) {
+  switch (__parser.__type_) {
+  case __format_spec::__type::__default:
+    __parser.__type_ = __format_spec::__type::__decimal;
+    [[fallthrough]];
+  case __format_spec::__type::__binary_lower_case:
+  case __format_spec::__type::__binary_upper_case:
+  case __format_spec::__type::__octal:
+  case __format_spec::__type::__decimal:
+  case __format_spec::__type::__hexadecimal_lower_case:
+  case __format_spec::__type::__hexadecimal_upper_case:
+    __process_display_type_integer(__parser);
+    break;
 
-    if (__begin != __end && *__begin != _CharT('}'))
-      __throw_format_error(
-          "The format-spec should consume the input or end with a '}'");
+  case __format_spec::__type::__char:
+    __process_display_type_char(__parser);
+    break;
 
-    return __begin;
-  }
+  default:
+    __throw_format_error("The format-spec type has a type not supported for "
+                         "an integer argument");
+  }
 
-  /** Processes the parsed std-format-spec based on the parsed display type. */
-  _LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type() {
-    switch (this->__type) {
-    case _Flags::_Type::__default:
-      // When no precision specified then it keeps default since that
-      // formatting differs from the other types.
-      if (this->__has_precision_field())
-        this->__type = _Flags::_Type::__general_lower_case;
-      break;
-    case _Flags::_Type::__float_hexadecimal_lower_case:
-    case _Flags::_Type::__float_hexadecimal_upper_case:
-      // Precision specific behavior will be handled later.
-      break;
-    case _Flags::_Type::__scientific_lower_case:
-    case _Flags::_Type::__scientific_upper_case:
-    case _Flags::_Type::__fixed_lower_case:
-    case _Flags::_Type::__fixed_upper_case:
-    case _Flags::_Type::__general_lower_case:
-    case _Flags::_Type::__general_upper_case:
-      if (!this->__has_precision_field()) {
-        // Set the default precision for the call to to_chars.
-        this->__precision = 6;
-        this->__precision_as_arg = false;
-      }
-      break;
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_floating_point(__parser<_CharT>& __parser) {
+  __resolve_zero_padding(__parser);
+
+  switch (__parser.__type_) {
+  case __format_spec::__type::__default:
+    if (__parser.__precision_as_arg_ || __parser.__has_precision())
+      __parser.__type_ = __format_spec::__type::__general_lower_case;
+  case __format_spec::__type::__float_hexadecimal_lower_case:
+  case __format_spec::__type::__float_hexadecimal_upper_case:
+  case __format_spec::__type::__scientific_lower_case:
+  case __format_spec::__type::__scientific_upper_case:
+  case __format_spec::__type::__fixed_lower_case:
+  case __format_spec::__type::__fixed_upper_case:
+  case __format_spec::__type::__general_lower_case:
+  case __format_spec::__type::__general_upper_case:
+    if (!__parser.__precision_as_arg_ && !__parser.__has_precision())
+      __parser.__precision_ = 6;
 
-    default:
-      __throw_format_error("The format-spec type has a type not supported for "
-                           "a floating-point argument");
-    }
-  }
-};
-
-/**
- * The parser for the std-format-spec.
- *
- * This implements the parser for the pointer types.
- *
- * See @ref __parser_string.
- */
-template <class _CharT>
-class _LIBCPP_TEMPLATE_VIS __parser_pointer : public __parser_width,              // provides __width(|as_arg)
-                                              public __parser_fill_align<_CharT>, // provides __fill and uses __flags
-                                              public _Flags                       // provides __flags
-{
-public:
-  using char_type = _CharT;
-
-  _LIBCPP_HIDE_FROM_ABI constexpr __parser_pointer() {
-    // Implements LWG3612 Inconsistent pointer alignment in std::format.
-    // The issue's current status is "Tentatively Ready" and libc++ status is
-    // still experimental.
-    //
-    // TODO FMT Validate this with the final resolution of LWG3612.
-    this->__alignment = _Flags::_Alignment::__right;
-  }
 
-  /**
-   * The low-level std-format-spec parse function.
-   *
-   * @pre __begin points at the beginning of the std-format-spec. This means
-   * directly after the ':'.
-   * @pre The std-format-spec parses the entire input, or the first unmatched
-   * character is a '}'.
-   *
-   * @returns The iterator pointing at the last parsed character.
-   */
-  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(auto& __parse_ctx) -> decltype(__parse_ctx.begin()) {
-    auto __it = __parse(__parse_ctx);
-    __process_display_type();
-    return __it;
-  }
-
-protected:
-  /**
-   * The low-level std-format-spec parse function.
-   *
-   * @pre __begin points at the beginning of the std-format-spec. This means
-   * directly after the ':'.
-   * @pre The std-format-spec parses the entire input, or the first unmatched
-   * character is a '}'.
-   *
-   * @returns The iterator pointing at the last parsed character.
-   */
-  _LIBCPP_HIDE_FROM_ABI constexpr auto __parse(auto& __parse_ctx) -> decltype(__parse_ctx.begin()) {
-    auto __begin = __parse_ctx.begin();
-    auto __end = __parse_ctx.end();
-    if (__begin == __end)
-      return __begin;
-
-    __begin = __parser_fill_align<_CharT>::__parse(__begin, __end, static_cast<_Flags&>(*this));
-    if (__begin == __end)
-      return __begin;
-
-    // An integer presentation type isn't defined in the Standard.
-    // Since a pointer is formatted as an integer it can be argued it's an
-    // integer presentation type. However there are two LWG-issues asserting it
-    // isn't an integer presentation type:
-    // - LWG3612 Inconsistent pointer alignment in std::format
-    // - LWG3644 std::format does not define "integer presentation type"
-    //
-    // There's a paper to make additional clarifications on the status of
-    // formatting pointers and proposes additional fields to be valid. That
-    // paper hasn't been reviewed by the Committee yet.
-    // - P2510 Formatting pointers
-    //
-    // The current implementation assumes formatting pointers isn't covered by
-    // "integer presentation type".
-    // TODO FMT Apply the LWG-issues/papers after approval/rejection by the Committee.
-
-    __begin = __parser_width::__parse(__begin, __end, __parse_ctx);
-    if (__begin == __end)
-      return __begin;
-
-    __begin = __parse_type(__begin, static_cast<_Flags&>(*this));
-
-    if (__begin != __end && *__begin != _CharT('}'))
-      __throw_format_error("The format-spec should consume the input or end with a '}'");
-
-    return __begin;
-  }
-
-  /** Processes the parsed std-format-spec based on the parsed display type. */
-  _LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type() {
-    switch (this->__type) {
-    case _Flags::_Type::__default:
-      this->__type = _Flags::_Type::__pointer;
-      break;
-    case _Flags::_Type::__pointer:
-      break;
-    default:
-      __throw_format_error("The format-spec type has a type not supported for a pointer argument");
-    }
-  }
-};
-
-/** Helper struct returned from @ref __get_string_alignment. */
-template <class _CharT>
-struct _LIBCPP_TEMPLATE_VIS __string_alignment {
-  /** Points beyond the last character to write to the output. */
-  const _CharT* __last;
-  /**
-   * The estimated number of columns in the output or 0.
-   *
-   * Only when the output needs to be aligned it's required to know the exact
-   * number of columns in the output. So if the formatted output has only a
-   * minimum width the exact size isn't important. It's only important to know
-   * the minimum has been reached. The minimum width is the width specified in
-   * the format-spec.
-   *
-   * For example in this code @code std::format("{:10}", MyString); @endcode
-   * the width estimation can stop once the algorithm has determined the output
-   * width is 10 columns.
-   *
-   * So if:
-   * * @ref __align == @c true the @ref __size is the estimated number of
-   *   columns required.
-   * * @ref __align == @c false the @ref __size is the estimated number of
-   *   columns required or 0 when the estimation algorithm stopped prematurely.
-   */
-  ptrdiff_t __size;
-  /**
-   * Does the output need to be aligned.
-   *
-   * When alignment is needed the output algorithm needs to add the proper
-   * padding. Else the output algorithm just needs to copy the input up to
-   * @ref __last.
-   */
-  bool __align;
-};
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_pointer(__format_spec::__type __type) {
+  switch (__type) {
+  case __format_spec::__type::__default:
+  case __format_spec::__type::__pointer:
+
+    __throw_format_error("The format-spec type has a type not supported for "
+                         "a pointer argument");
 
 #ifndef _LIBCPP_HAS_NO_UNICODE
 namespace __detail {
 
 /**
  * Unicode column width estimates.
  *
  * Unicode can be stored in several formats: UTF-8, UTF-16, and UTF-32.
while (__first != __last) {
     if (__result >= __maximum)
       return {__result, __first};
   }
 
   return {__result, __first};
 }
 
 } // namespace __detail
-
-template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI constexpr __string_alignment<_CharT>
-__get_string_alignment(const _CharT* __first, const _CharT* __last,
-                       ptrdiff_t __width, ptrdiff_t __precision) noexcept {
-  _LIBCPP_ASSERT(__width != 0 || __precision != -1,
-                 "The function has no effect and shouldn't be used");
-
-  // TODO FMT There might be more optimizations possible:
-  // If __precision == __format::__number_max and the encoding is:
-  // * UTF-8  : 4 * (__last - __first) >= __width
-  // * UTF-16 : 2 * (__last - __first) >= __width
-  // * UTF-32 : (__last - __first) >= __width
-  // In these cases it's certain the output is at least the requested width.
-  // It's unknown how often this happens in practice. For now the improvement
-  // isn't implemented.
-
-  /*
-   * First assume there are no special Unicode code units in the input.
-   * - Apply the precision (this may reduce the size of the input). When
-   *   __precison == -1 this step is omitted.
-   * - Scan for special code units in the input.
-   * If our assumption was correct the __pos will be at the end of the input.
-   */
-  const ptrdiff_t __length = __last - __first;
-  const _CharT* __limit =
-      __first +
-      (__precision == -1 ? __length : _VSTD::min(__length, __precision));
-  ptrdiff_t __size = __limit - __first;
-  const _CharT* __pos =
-      __detail::__estimate_column_width_fast(__first, __limit);
-
-  if (__pos == __limit)
-    return {__limit, __size, __size < __width};
-
-  /*
-   * Our assumption was wrong, there are special Unicode code units.
-   * The range [__first, __pos) contains a set of code units with the
-   * following property:
-   *      Every _CharT in the range will be rendered in 1 column.
-   *
-   * If there's no maximum width and the parsed size already exceeds the
-   *   minimum required width. The real size isn't important. So bail out.
-   */
-  if (__precision == -1 && (__pos - __first) >= __width)
-    return {__last, 0, false};
-
-  /* If there's a __precision, truncate the output to that width. */
-  ptrdiff_t __prefix = __pos - __first;
-  if (__precision != -1) {
-    _LIBCPP_ASSERT(__precision > __prefix, "Logic error.");
-    auto __lengh_info = __detail::__estimate_column_width(
-        __pos, __last, __precision - __prefix);
-    __size = __lengh_info.__width + __prefix;
-    return {__lengh_info.__ptr, __size, __size < __width};
-  }
-
-  /* Else use __width to determine the number of required padding characters. */
-  _LIBCPP_ASSERT(__width > __prefix, "Logic error.");
-  /*
-   * The column width is always one or two columns. For the precision the wanted
-   * column width is the maximum, for the width it's the minimum. Using the
-   * width estimation with its truncating behavior will result in the wrong
-   * result in the following case:
-   * - The last code unit processed requires two columns and exceeds the
-   *   maximum column width.
-   * By increasing the __maximum by one avoids this issue. (It means it may
-   * pass one code point more than required to determine the proper result;
-   * that however isn't a problem for the algorithm.)
-   */
-  size_t __maximum = 1 + __width - __prefix;
-  auto __lengh_info =
-      __detail::__estimate_column_width(__pos, __last, __maximum);
-  if (__lengh_info.__ptr != __last) {
-    // Consumed the width number of code units. The exact size of the string
-    // is unknown. We only know we don't need to align the output.
-    _LIBCPP_ASSERT(static_cast<ptrdiff_t>(__lengh_info.__width + __prefix) >=
-                       __width,
-                   "Logic error");
-    return {__last, 0, false};
-  }
-
-  __size = __lengh_info.__width + __prefix;
-  return {__last, __size, __size < __width};
-}
-#else  // _LIBCPP_HAS_NO_UNICODE
-template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI constexpr __string_alignment<_CharT>
-__get_string_alignment(const _CharT* __first, const _CharT* __last,
-                       ptrdiff_t __width, ptrdiff_t __precision) noexcept {
-  const ptrdiff_t __length = __last - __first;
-  const _CharT* __limit =
-      __first +
-      (__precision == -1 ? __length : _VSTD::min(__length, __precision));
-  ptrdiff_t __size = __limit - __first;
-  return {__limit, __size, __size < __width};
-}
 #endif // _LIBCPP_HAS_NO_UNICODE
 
 } // namespace __format_spec
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___FORMAT_PARSER_STD_FORMAT_SPEC_H

libcxx/include/format

 #include <__format/format_parse_context.h>
 #include <__format/format_string.h>
 #include <__format/format_to_n_result.h>
 #include <__format/formatter.h>
 #include <__format/formatter_bool.h>
 #include <__format/formatter_char.h>
 #include <__format/formatter_floating_point.h>
 #include <__format/formatter_integer.h>
+#include <__format/formatter_output.h>
 #include <__format/formatter_pointer.h>
 #include <__format/formatter_string.h>
 #include <__format/parser_std_format_spec.h>
 #include <__variant/monostate.h>
 #include <array>
 #include <concepts>
 #include <string>
 #include <string_view>

libcxx/include/module.modulemap

module __format {
       module format_string            { private header "__format/format_string.h" }
       module format_to_n_result       { private header "__format/format_to_n_result.h" }
       module formatter                { private header "__format/formatter.h" }
       module formatter_bool           { private header "__format/formatter_bool.h" }
       module formatter_char           { private header "__format/formatter_char.h" }
       module formatter_floating_point { private header "__format/formatter_floating_point.h" }
       module formatter_integer        { private header "__format/formatter_integer.h" }
       module formatter_integral       { private header "__format/formatter_integral.h" }
+      module formatter_output         { private header "__format/formatter_output.h" }
       module formatter_pointer        { private header "__format/formatter_pointer.h" }
       module formatter_string         { private header "__format/formatter_string.h" }
       module parser_std_format_spec   { private header "__format/parser_std_format_spec.h" }
     }
   }
   module forward_list {
     header "forward_list"
     export initializer_list

libcxx/test/libcxx/clang_tidy.sh.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: has-clang-tidy
 // XFAIL: modules-build
 
+// Display the clang-tidy version for debugging purposes.
+// RUN: clang-tidy --version
 // RUN: clang-tidy %s --warnings-as-errors=* -header-filter=.* -- -Wno-unknown-warning-option %{compile_flags}
 // -Wno-unknown-warning-option tells clang-tidy to ignore '-W' command-line arguments that it doesn't know.
 // There are some GCC-specific ones where clang-tidy would warn otherwise.
 
 // Prevent <ext/hash_map> from generating deprecated warnings for this test.
 #if defined(__DEPRECATED)
 #    undef __DEPRECATED
 #endif

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__format/format_string.h> // expected-error@*:* {{use of private header from outside its module: '__format/format_string.h'}}
 #include <__format/format_to_n_result.h> // expected-error@*:* {{use of private header from outside its module: '__format/format_to_n_result.h'}}
 #include <__format/formatter.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter.h'}}
 #include <__format/formatter_bool.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_bool.h'}}
 #include <__format/formatter_char.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_char.h'}}
 #include <__format/formatter_floating_point.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_floating_point.h'}}
 #include <__format/formatter_integer.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_integer.h'}}
 #include <__format/formatter_integral.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_integral.h'}}
+#include <__format/formatter_output.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_output.h'}}
 #include <__format/formatter_pointer.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_pointer.h'}}
 #include <__format/formatter_string.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_string.h'}}
 #include <__format/parser_std_format_spec.h> // expected-error@*:* {{use of private header from outside its module: '__format/parser_std_format_spec.h'}}
 #include <__functional/binary_function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/binary_function.h'}}
 #include <__functional/binary_negate.h> // expected-error@*:* {{use of private header from outside its module: '__functional/binary_negate.h'}}
 #include <__functional/bind.h> // expected-error@*:* {{use of private header from outside its module: '__functional/bind.h'}}
 #include <__functional/bind_back.h> // expected-error@*:* {{use of private header from outside its module: '__functional/bind_back.h'}}
 #include <__functional/bind_front.h> // expected-error@*:* {{use of private header from outside its module: '__functional/bind_front.h'}}

libcxx/test/libcxx/utilities/format/format.string/format.string.std/concepts_precision.h

-//===----------------------------------------------------------------------===//
-// 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 LIBCXX_TEST_STD_UTILITIES_FORMAT_FORMAT_STRING_FORMAT_STRING_STD_CONCEPTS_PRECISION_H
-#define LIBCXX_TEST_STD_UTILITIES_FORMAT_FORMAT_STRING_FORMAT_STRING_STD_CONCEPTS_PRECISION_H
-
-template <class T>
-concept has_precision = requires(T parser) {
-  parser.__precision;
-};
-
-template <class T>
-concept has_precision_as_arg = requires(T parser) {
-  parser.__precision_as_arg;
-};
-
-#endif // LIBCXX_TEST_STD_UTILITIES_FORMAT_FORMAT_STRING_FORMAT_STRING_STD_CONCEPTS_PRECISION_H

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_bool.pass.cpp

-//===----------------------------------------------------------------------===//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-has-no-incomplete-format
-
-// <format>
-
-// Tests the parsing of the format string as specified in [format.string.std].
-// It validates whether the std-format-spec is valid for a boolean type.
-
-#include <format>
-#include <cassert>
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
-# include <iostream>
-#endif
-
-#include "concepts_precision.h"
-#include "test_macros.h"
-#include "make_string.h"
-#include "test_exception.h"
-
-#define CSTR(S) MAKE_CSTRING(CharT, S)
-
-using namespace std::__format_spec;
-
-template <class CharT>
-using Parser = __parser_bool<CharT>;
-
-template <class CharT>
-struct Expected {
-  CharT fill = CharT(' ');
-  _Flags::_Alignment alignment = _Flags::_Alignment::__left;
-  _Flags::_Sign sign = _Flags::_Sign::__default;
-  bool alternate_form = false;
-  bool zero_padding = false;
-  uint32_t width = 0;
-  bool width_as_arg = false;
-  bool locale_specific_form = false;
-  _Flags::_Type type = _Flags::_Type::__string;
-};
-
-template <class CharT>
-constexpr void test(Expected<CharT> expected, size_t size,
-                    std::basic_string_view<CharT> fmt) {
-  // Initialize parser with sufficient arguments to avoid the parsing to fail
-  // due to insufficient arguments.
-  std::basic_format_parse_context<CharT> parse_ctx(fmt,
-                                                   std::__format::__number_max);
-  auto begin = parse_ctx.begin();
-  auto end = parse_ctx.end();
-  Parser<CharT> parser;
-  auto it = parser.parse(parse_ctx);
-
-  assert(begin == parse_ctx.begin());
-  assert(end == parse_ctx.end());
-
-  assert(begin + size == it);
-  assert(parser.__fill == expected.fill);
-  assert(parser.__alignment == expected.alignment);
-  assert(parser.__sign == expected.sign);
-  assert(parser.__alternate_form == expected.alternate_form);
-  assert(parser.__zero_padding == expected.zero_padding);
-  assert(parser.__width == expected.width);
-  assert(parser.__width_as_arg == expected.width_as_arg);
-  assert(parser.__locale_specific_form == expected.locale_specific_form);
-  assert(parser.__type == expected.type);
-}
-
-template <class CharT>
-constexpr void test(Expected<CharT> expected, size_t size, const CharT* f) {
-  // The format-spec is valid if completely consumed or terminates at a '}'.
-  // The valid inputs all end with a '}'. The test is executed twice:
-  // - first with the terminating '}',
-  // - second consuming the entire input.
-  std::basic_string_view<CharT> fmt{f};
-  assert(fmt.back() == CharT('}') && "Pre-condition failure");
-
-  test(expected, size, fmt);
-  fmt.remove_suffix(1);
-  test(expected, size, fmt);
-}
-
-template <class CharT>
-constexpr void test_as_string() {
-
-  test({}, 1, CSTR("s}"));
-
-  // *** Align-fill ***
-  test({.alignment = _Flags::_Alignment::__left}, 1, CSTR("<}"));
-  test({.alignment = _Flags::_Alignment::__center}, 1, "^}");
-  test({.alignment = _Flags::_Alignment::__right}, 1, ">}");
-
-  test({.alignment = _Flags::_Alignment::__left}, 2, CSTR("<s}"));
-  test({.alignment = _Flags::_Alignment::__center}, 2, "^s}");
-  test({.alignment = _Flags::_Alignment::__right}, 2, ">s}");
-
-  test({.fill = CharT('L'), .alignment = _Flags::_Alignment::__left}, 2,
-       CSTR("L<}"));
-  test({.fill = CharT('#'), .alignment = _Flags::_Alignment::__center}, 2,
-       CSTR("#^}"));
-  test({.fill = CharT('0'), .alignment = _Flags::_Alignment::__right}, 2,
-       CSTR("0>}"));
-
-  test({.fill = CharT('L'), .alignment = _Flags::_Alignment::__left}, 3,
-       CSTR("L<s}"));
-  test({.fill = CharT('#'), .alignment = _Flags::_Alignment::__center}, 3,
-       CSTR("#^s}"));
-  test({.fill = CharT('0'), .alignment = _Flags::_Alignment::__right}, 3,
-       CSTR("0>s}"));
-
-  // *** Sign ***
-  test_exception<Parser<CharT>>(
-      "A sign field isn't allowed in this format-spec", CSTR("-}"));
-  test_exception<Parser<CharT>>(
-      "A sign field isn't allowed in this format-spec", CSTR("-s}"));
-
-  // *** Alternate form ***
-  test_exception<Parser<CharT>>(
-      "An alternate form field isn't allowed in this format-spec", CSTR("#}"));
-  test_exception<Parser<CharT>>(
-      "An alternate form field isn't allowed in this format-spec", CSTR("#s}"));
-
-  // *** Zero padding ***
-  test_exception<Parser<CharT>>(
-      "A zero-padding field isn't allowed in this format-spec", CSTR("0}"));
-  test_exception<Parser<CharT>>(
-      "A zero-padding field isn't allowed in this format-spec", CSTR("0s}"));
-
-  // *** Width ***
-  test({.width = 0, .width_as_arg = false}, 0, CSTR("}"));
-  test({.width = 1, .width_as_arg = false}, 1, CSTR("1}"));
-  test({.width = 10, .width_as_arg = false}, 2, CSTR("10}"));
-  test({.width = 1000, .width_as_arg = false}, 4, CSTR("1000}"));
-  test({.width = 1000000, .width_as_arg = false}, 7, CSTR("1000000}"));
-
-  test({.width = 0, .width_as_arg = true}, 2, CSTR("{}}"));
-  test({.width = 0, .width_as_arg = true}, 3, CSTR("{0}}"));
-  test({.width = 1, .width_as_arg = true}, 3, CSTR("{1}}"));
-
-  test_exception<Parser<CharT>>(
-      "A format-spec width field shouldn't have a leading zero", CSTR("00"));
-
-  static_assert(std::__format::__number_max == 2'147'483'647,
-                "Update the assert and the test.");
-  test({.width = 2'147'483'647, .width_as_arg = false}, 10,
-       CSTR("2147483647}"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large", CSTR("2147483648"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large", CSTR("5000000000"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large", CSTR("10000000000"));
-
-  test_exception<Parser<CharT>>("End of input while parsing format-spec arg-id",
-                                CSTR("{"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{0"));
-  test_exception<Parser<CharT>>(
-      "The arg-id of the format-spec starts with an invalid character",
-      CSTR("{a"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{1"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{9"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{9:"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{9a"));
-
-  static_assert(std::__format::__number_max == 2'147'483'647,
-                "Update the assert and the test.");
-  // Note the static_assert tests whether the arg-id is valid.
-  // Therefore the following should be true arg-id < __format::__number_max.
-  test({.width = 2'147'483'646, .width_as_arg = true}, 12,
-       CSTR("{2147483646}}"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large",
-      CSTR("{2147483648}"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large",
-      CSTR("{5000000000}"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large",
-      CSTR("{10000000000}"));
-
-  // *** Precision ***
-  test_exception<Parser<CharT>>(
-      "The format-spec should consume the input or end with a '}'", CSTR("."));
-  test_exception<Parser<CharT>>(
-      "The format-spec should consume the input or end with a '}'", CSTR(".1"));
-
-  // *** Locale-specific form ***
-  test({.locale_specific_form = true}, 1, CSTR("L}"));
-  test({.locale_specific_form = true}, 2, CSTR("Ls}"));
-}
-
-template <class CharT>
-constexpr void test_as_integer() {
-
-  test({.alignment = _Flags::_Alignment::__right,
-        .type = _Flags::_Type::__decimal},
-       1, CSTR("d}"));
-
-  // *** Align-fill ***
-  test({.alignment = _Flags::_Alignment::__left,
-        .type = _Flags::_Type::__decimal},
-       2, CSTR("<d}"));
-  test({.alignment = _Flags::_Alignment::__center,
-        .type = _Flags::_Type::__decimal},
-       2, "^d}");
-  test({.alignment = _Flags::_Alignment::__right,
-        .type = _Flags::_Type::__decimal},
-       2, ">d}");
-
-  test({.fill = CharT('L'),
-        .alignment = _Flags::_Alignment::__left,
-        .type = _Flags::_Type::__decimal},
-       3, CSTR("L<d}"));
-  test({.fill = CharT('#'),
-        .alignment = _Flags::_Alignment::__center,
-        .type = _Flags::_Type::__decimal},
-       3, CSTR("#^d}"));
-  test({.fill = CharT('0'),
-        .alignment = _Flags::_Alignment::__right,
-        .type = _Flags::_Type::__decimal},
-       3, CSTR("0>d}"));
-
-  // *** Sign ***
-  test({.alignment = _Flags::_Alignment::__right,
-        .sign = _Flags::_Sign::__minus,
-        .type = _Flags::_Type::__decimal},
-       2, CSTR("-d}"));
-  test({.alignment = _Flags::_Alignment::__right,
-        .sign = _Flags::_Sign::__plus,
-        .type = _Flags::_Type::__decimal},
-       2, CSTR("+d}"));
-  test({.alignment = _Flags::_Alignment::__right,
-        .sign = _Flags::_Sign::__space,
-        .type = _Flags::_Type::__decimal},
-       2, CSTR(" d}"));
-
-  // *** Alternate form ***
-  test({.alignment = _Flags::_Alignment::__right,
-        .alternate_form = true,
-        .type = _Flags::_Type::__decimal},
-       2, CSTR("#d}"));
-
-  // *** Zero padding ***
-  test({.alignment = _Flags::_Alignment::__default,
-        .zero_padding = true,
-        .type = _Flags::_Type::__decimal},
-       2, CSTR("0d}"));
-  test({.alignment = _Flags::_Alignment::__center,
-        .type = _Flags::_Type::__decimal},
-       3, CSTR("^0d}"));
-
-  // *** Width ***
-  test({.alignment = _Flags::_Alignment::__right,
-        .width = 0,
-        .width_as_arg = false,
-        .type = _Flags::_Type::__decimal},
-       1, CSTR("d}"));
-  test({.alignment = _Flags::_Alignment::__right,
-        .width = 1,
-        .width_as_arg = false,
-        .type = _Flags::_Type::__decimal},
-       2, CSTR("1d}"));
-  test({.alignment = _Flags::_Alignment::__right,
-        .width = 10,
-        .width_as_arg = false,
-        .type = _Flags::_Type::__decimal},
-       3, CSTR("10d}"));
-  test({.alignment = _Flags::_Alignment::__right,
-        .width = 1000,
-        .width_as_arg = false,
-        .type = _Flags::_Type::__decimal},
-       5, CSTR("1000d}"));
-  test({.alignment = _Flags::_Alignment::__right,
-        .width = 1000000,
-        .width_as_arg = false,
-        .type = _Flags::_Type::__decimal},
-       8, CSTR("1000000d}"));
-
-  test({.alignment = _Flags::_Alignment::__right,
-        .width = 0,
-        .width_as_arg = true,
-        .type = _Flags::_Type::__decimal},
-       3, CSTR("{}d}"));
-  test({.alignment = _Flags::_Alignment::__right,
-        .width = 0,
-        .width_as_arg = true,
-        .type = _Flags::_Type::__decimal},
-       4, CSTR("{0}d}"));
-  test({.alignment = _Flags::_Alignment::__right,
-        .width = 1,
-        .width_as_arg = true,
-        .type = _Flags::_Type::__decimal},
-       4, CSTR("{1}d}"));
-
-  // *** Precision ***
-  test_exception<Parser<CharT>>(
-      "The format-spec should consume the input or end with a '}'", CSTR("."));
-  test_exception<Parser<CharT>>(
-      "The format-spec should consume the input or end with a '}'", CSTR(".1"));
-
-  // *** Locale-specific form ***
-  test({.alignment = _Flags::_Alignment::__right,
-        .locale_specific_form = true,
-        .type = _Flags::_Type::__decimal},
-       2, CSTR("Ld}"));
-}
-
-template <class CharT>
-constexpr void test() {
-  Parser<CharT> parser;
-
-  assert(parser.__fill == CharT(' '));
-  assert(parser.__alignment == _Flags::_Alignment::__default);
-  assert(parser.__sign == _Flags::_Sign::__default);
-  assert(parser.__alternate_form == false);
-  assert(parser.__zero_padding == false);
-  assert(parser.__width == 0);
-  assert(parser.__width_as_arg == false);
-  static_assert(!has_precision<decltype(parser)>);
-  static_assert(!has_precision_as_arg<decltype(parser)>);
-  assert(parser.__locale_specific_form == false);
-  assert(parser.__type == _Flags::_Type::__default);
-
-  test({}, 0, CSTR("}"));
-
-  test_as_string<CharT>();
-  test_as_integer<CharT>();
-
-  // *** Type ***
-  {
-    const char* expected =
-        "The format-spec type has a type not supported for a bool argument";
-    test_exception<Parser<CharT>>(expected, CSTR("A}"));
-    test_exception<Parser<CharT>>(expected, CSTR("E}"));
-    test_exception<Parser<CharT>>(expected, CSTR("F}"));
-    test_exception<Parser<CharT>>(expected, CSTR("G}"));
-    test_exception<Parser<CharT>>(expected, CSTR("a}"));
-    test_exception<Parser<CharT>>(expected, CSTR("c}"));
-    test_exception<Parser<CharT>>(expected, CSTR("e}"));
-    test_exception<Parser<CharT>>(expected, CSTR("f}"));
-    test_exception<Parser<CharT>>(expected, CSTR("g}"));
-    test_exception<Parser<CharT>>(expected, CSTR("p}"));
-  }
-
-  // **** General ***
-  test_exception<Parser<CharT>>(
-      "The format-spec should consume the input or end with a '}'", CSTR("ss"));
-}
-
-constexpr bool test() {
-  test<char>();
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  test<wchar_t>();
-#endif
-
-  return true;
-}
-
-int main(int, char**) {
-#ifndef _WIN32
-  // Make sure the parsers match the expectations. The layout of the
-  // subobjects is chosen to minimize the size required.
-  static_assert(sizeof(Parser<char>) == 2 * sizeof(uint32_t));
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  static_assert(
-      sizeof(Parser<wchar_t>) ==
-      (sizeof(wchar_t) <= 2 ? 2 * sizeof(uint32_t) : 3 * sizeof(uint32_t)));
-#endif
-#endif // _WIN32
-
-  test();
-  static_assert(test());
-
-  return 0;
-}

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_char.pass.cpp

-//===----------------------------------------------------------------------===//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-has-no-incomplete-format
-
-// <format>
-
-// Tests the parsing of the format string as specified in [format.string.std].
-// It validates whether the std-format-spec is valid for a char type.
-
-#include <format>
-#include <cassert>
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
-# include <iostream>
-#endif
-
-#include "concepts_precision.h"
-#include "test_macros.h"
-#include "make_string.h"
-#include "test_exception.h"
-
-#define CSTR(S) MAKE_CSTRING(CharT, S)
-
-using namespace std::__format_spec;
-
-template <class CharT>
-using Parser = __parser_char<CharT>;
-
-template <class CharT>
-struct Expected {
-  CharT fill = CharT(' ');
-  _Flags::_Alignment alignment = _Flags::_Alignment::__left;
-  _Flags::_Sign sign = _Flags::_Sign::__default;
-  bool alternate_form = false;
-  bool zero_padding = false;
-  uint32_t width = 0;
-  bool width_as_arg = false;
-  bool locale_specific_form = false;
-  _Flags::_Type type = _Flags::_Type::__char;
-};
-
-template <class CharT>
-constexpr void test(Expected<CharT> expected, size_t size,
-                    std::basic_string_view<CharT> fmt) {
-  // Initialize parser with sufficient arguments to avoid the parsing to fail
-  // due to insufficient arguments.
-  std::basic_format_parse_context<CharT> parse_ctx(fmt,
-                                                   std::__format::__number_max);
-  auto begin = parse_ctx.begin();
-  auto end = parse_ctx.end();
-  Parser<CharT> parser;
-  auto it = parser.parse(parse_ctx);
-
-  assert(begin == parse_ctx.begin());
-  assert(end == parse_ctx.end());
-
-  assert(begin + size == it);
-  assert(parser.__fill == expected.fill);
-  assert(parser.__alignment == expected.alignment);
-  assert(parser.__sign == expected.sign);
-  assert(parser.__alternate_form == expected.alternate_form);
-  assert(parser.__zero_padding == expected.zero_padding);
-  assert(parser.__width == expected.width);
-  assert(parser.__width_as_arg == expected.width_as_arg);
-  assert(parser.__locale_specific_form == expected.locale_specific_form);
-  assert(parser.__type == expected.type);
-}
-
-template <class CharT>
-constexpr void test(Expected<CharT> expected, size_t size, const CharT* f) {
-  // The format-spec is valid if completely consumed or terminates at a '}'.
-  // The valid inputs all end with a '}'. The test is executed twice:
-  // - first with the terminating '}',
-  // - second consuming the entire input.
-  std::basic_string_view<CharT> fmt{f};
-  assert(fmt.back() == CharT('}') && "Pre-condition failure");
-
-  test(expected, size, fmt);
-  fmt.remove_suffix(1);
-  test(expected, size, fmt);
-}
-
-template <class CharT>
-constexpr void test_as_char() {
-
-  test({}, 1, CSTR("c}"));
-
-  // *** Align-fill ***
-  test({.alignment = _Flags::_Alignment::__left}, 1, CSTR("<}"));
-  test({.alignment = _Flags::_Alignment::__center}, 1, "^}");
-  test({.alignment = _Flags::_Alignment::__right}, 1, ">}");
-
-  test({.alignment = _Flags::_Alignment::__left}, 2, CSTR("<c}"));
-  test({.alignment = _Flags::_Alignment::__center}, 2, "^c}");
-  test({.alignment = _Flags::_Alignment::__right}, 2, ">c}");
-
-  test({.fill = CharT('L'), .alignment = _Flags::_Alignment::__left}, 2,
-       CSTR("L<}"));
-  test({.fill = CharT('#'), .alignment = _Flags::_Alignment::__center}, 2,
-       CSTR("#^}"));
-  test({.fill = CharT('0'), .alignment = _Flags::_Alignment::__right}, 2,
-       CSTR("0>}"));
-
-  test({.fill = CharT('L'), .alignment = _Flags::_Alignment::__left}, 3,
-       CSTR("L<c}"));
-  test({.fill = CharT('#'), .alignment = _Flags::_Alignment::__center}, 3,
-       CSTR("#^c}"));
-  test({.fill = CharT('0'), .alignment = _Flags::_Alignment::__right}, 3,
-       CSTR("0>c}"));
-
-  // *** Sign ***
-  test_exception<Parser<CharT>>(
-      "A sign field isn't allowed in this format-spec", CSTR("-"));
-  test_exception<Parser<CharT>>(
-      "A sign field isn't allowed in this format-spec", CSTR("+"));
-  test_exception<Parser<CharT>>(
-      "A sign field isn't allowed in this format-spec", CSTR(" "));
-
-  test_exception<Parser<CharT>>(
-      "A sign field isn't allowed in this format-spec", CSTR("-c"));
-  test_exception<Parser<CharT>>(
-      "A sign field isn't allowed in this format-spec", CSTR("+c"));
-  test_exception<Parser<CharT>>(
-      "A sign field isn't allowed in this format-spec", CSTR(" c"));
-
-  // *** Alternate form ***
-  test_exception<Parser<CharT>>(
-      "An alternate form field isn't allowed in this format-spec", CSTR("#}"));
-  test_exception<Parser<CharT>>(
-      "An alternate form field isn't allowed in this format-spec", CSTR("#c}"));
-
-  // *** Zero padding ***
-  test_exception<Parser<CharT>>(
-      "A zero-padding field isn't allowed in this format-spec", CSTR("0}"));
-  test_exception<Parser<CharT>>(
-      "A zero-padding field isn't allowed in this format-spec", CSTR("0c}"));
-
-  // *** Width ***
-  test({.width = 0, .width_as_arg = false}, 0, CSTR("}"));
-  test({.width = 1, .width_as_arg = false}, 1, CSTR("1}"));
-  test({.width = 10, .width_as_arg = false}, 2, CSTR("10}"));
-  test({.width = 1000, .width_as_arg = false}, 4, CSTR("1000}"));
-  test({.width = 1000000, .width_as_arg = false}, 7, CSTR("1000000}"));
-
-  test({.width = 0, .width_as_arg = true}, 2, CSTR("{}}"));
-  test({.width = 0, .width_as_arg = true}, 3, CSTR("{0}}"));
-  test({.width = 1, .width_as_arg = true}, 3, CSTR("{1}}"));
-
-  test_exception<Parser<CharT>>(
-      "A format-spec width field shouldn't have a leading zero", CSTR("00"));
-
-  static_assert(std::__format::__number_max == 2'147'483'647,
-                "Update the assert and the test.");
-  test({.width = 2'147'483'647, .width_as_arg = false}, 10,
-       CSTR("2147483647}"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large", CSTR("2147483648"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large", CSTR("5000000000"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large", CSTR("10000000000"));
-
-  test_exception<Parser<CharT>>("End of input while parsing format-spec arg-id",
-                                CSTR("{"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{0"));
-  test_exception<Parser<CharT>>(
-      "The arg-id of the format-spec starts with an invalid character",
-      CSTR("{a"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{1"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{9"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{9:"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{9a"));
-
-  static_assert(std::__format::__number_max == 2'147'483'647,
-                "Update the assert and the test.");
-  // Note the static_assert tests whether the arg-id is valid.
-  // Therefore the following should be true arg-id < __format::__number_max.
-  test({.width = 2'147'483'646, .width_as_arg = true}, 12,
-       CSTR("{2147483646}}"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large",
-      CSTR("{2147483648}"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large",
-      CSTR("{5000000000}"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large",
-      CSTR("{10000000000}"));
-
-  // *** Precision ***
-  test_exception<Parser<CharT>>(
-      "The format-spec should consume the input or end with a '}'", CSTR("."));
-  test_exception<Parser<CharT>>(
-      "The format-spec should consume the input or end with a '}'", CSTR(".1"));
-
-  // *** Locale-specific form ***
-  // Note the flag is allowed, but has no effect.
-  test({.locale_specific_form = true}, 1, CSTR("L}"));
-  test({.locale_specific_form = true}, 2, CSTR("Lc}"));
-}
-
-template <class CharT>
-constexpr void test_as_integer() {
-
-  test({.alignment = _Flags::_Alignment::__right,
-        .type = _Flags::_Type::__decimal},
-       1, CSTR("d}"));
-
-  // *** Align-fill ***
-  test({.alignment = _Flags::_Alignment::__left,
-        .type = _Flags::_Type::__decimal},
-       2, CSTR("<d}"));
-  test({.alignment = _Flags::_Alignment::__center,
-        .type = _Flags::_Type::__decimal},
-       2, "^d}");
-  test({.alignment = _Flags::_Alignment::__right,
-        .type = _Flags::_Type::__decimal},
-       2, ">d}");
-
-  test({.fill = CharT('L'),
-        .alignment = _Flags::_Alignment::__left,
-        .type = _Flags::_Type::__decimal},
-       3, CSTR("L<d}"));
-  test({.fill = CharT('#'),
-        .alignment = _Flags::_Alignment::__center,
-        .type = _Flags::_Type::__decimal},
-       3, CSTR("#^d}"));
-  test({.fill = CharT('0'),
-        .alignment = _Flags::_Alignment::__right,
-        .type = _Flags::_Type::__decimal},
-       3, CSTR("0>d}"));
-
-  // *** Sign ***
-  test({.alignment = _Flags::_Alignment::__right,
-        .sign = _Flags::_Sign::__minus,
-        .type = _Flags::_Type::__decimal},
-       2, CSTR("-d}"));
-  test({.alignment = _Flags::_Alignment::__right,
-        .sign = _Flags::_Sign::__plus,
-        .type = _Flags::_Type::__decimal},
-       2, CSTR("+d}"));
-  test({.alignment = _Flags::_Alignment::__right,
-        .sign = _Flags::_Sign::__space,
-        .type = _Flags::_Type::__decimal},
-       2, CSTR(" d}"));
-
-  // *** Alternate form ***
-  test({.alignment = _Flags::_Alignment::__right,
-        .alternate_form = true,
-        .type = _Flags::_Type::__decimal},
-       2, CSTR("#d}"));
-
-  // *** Zero padding ***
-  test({.alignment = _Flags::_Alignment::__default,
-        .zero_padding = true,
-        .type = _Flags::_Type::__decimal},
-       2, CSTR("0d}"));
-  test({.alignment = _Flags::_Alignment::__center,
-        .type = _Flags::_Type::__decimal},
-       3, CSTR("^0d}"));
-
-  // *** Width ***
-  test({.alignment = _Flags::_Alignment::__right,
-        .width = 0,
-        .width_as_arg = false,
-        .type = _Flags::_Type::__decimal},
-       1, CSTR("d}"));
-  test({.alignment = _Flags::_Alignment::__right,
-        .width = 1,
-        .width_as_arg = false,
-        .type = _Flags::_Type::__decimal},
-       2, CSTR("1d}"));
-  test({.alignment = _Flags::_Alignment::__right,
-        .width = 10,
-        .width_as_arg = false,
-        .type = _Flags::_Type::__decimal},
-       3, CSTR("10d}"));
-  test({.alignment = _Flags::_Alignment::__right,
-        .width = 1000,
-        .width_as_arg = false,
-        .type = _Flags::_Type::__decimal},
-       5, CSTR("1000d}"));
-  test({.alignment = _Flags::_Alignment::__right,
-        .width = 1000000,
-        .width_as_arg = false,
-        .type = _Flags::_Type::__decimal},
-       8, CSTR("1000000d}"));
-
-  test({.alignment = _Flags::_Alignment::__right,
-        .width = 0,
-        .width_as_arg = true,
-        .type = _Flags::_Type::__decimal},
-       3, CSTR("{}d}"));
-  test({.alignment = _Flags::_Alignment::__right,
-        .width = 0,
-        .width_as_arg = true,
-        .type = _Flags::_Type::__decimal},
-       4, CSTR("{0}d}"));
-  test({.alignment = _Flags::_Alignment::__right,
-        .width = 1,
-        .width_as_arg = true,
-        .type = _Flags::_Type::__decimal},
-       4, CSTR("{1}d}"));
-
-  // *** Precision ***
-  test_exception<Parser<CharT>>(
-      "The format-spec should consume the input or end with a '}'", CSTR("."));
-  test_exception<Parser<CharT>>(
-      "The format-spec should consume the input or end with a '}'", CSTR(".1"));
-
-  // *** Locale-specific form ***
-  test({.alignment = _Flags::_Alignment::__right,
-        .locale_specific_form = true,
-        .type = _Flags::_Type::__decimal},
-       2, CSTR("Ld}"));
-}
-
-template <class CharT>
-constexpr void test() {
-  Parser<CharT> parser;
-
-  assert(parser.__fill == CharT(' '));
-  assert(parser.__alignment == _Flags::_Alignment::__default);
-  assert(parser.__sign == _Flags::_Sign::__default);
-  assert(parser.__alternate_form == false);
-  assert(parser.__zero_padding == false);
-  assert(parser.__width == 0);
-  assert(parser.__width_as_arg == false);
-  static_assert(!has_precision<decltype(parser)>);
-  static_assert(!has_precision_as_arg<decltype(parser)>);
-  assert(parser.__locale_specific_form == false);
-  assert(parser.__type == _Flags::_Type::__default);
-
-  test({}, 0, CSTR("}"));
-
-  test_as_char<CharT>();
-  test_as_integer<CharT>();
-
-  // *** Type ***
-  {
-    const char* unsuported_type =
-        "The format-spec type has a type not supported for a char argument";
-    const char* not_a_type =
-        "The format-spec should consume the input or end with a '}'";
-
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("A}"));
-    test({.alignment = _Flags::_Alignment::__right,
-          .type = _Flags::_Type::__binary_upper_case},
-         1, CSTR("B}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("C}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("D}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("E}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("F}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("G}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("H}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("I}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("J}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("K}"));
-    test({.locale_specific_form = true}, 1, CSTR("L}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("M}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("N}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("O}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("P}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("Q}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("R}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("S}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("T}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("U}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("V}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("W}"));
-    test({.alignment = _Flags::_Alignment::__right,
-          .type = _Flags::_Type::__hexadecimal_upper_case},
-         1, CSTR("X}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("Y}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("Z}"));
-
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("a}"));
-    test({.alignment = _Flags::_Alignment::__right,
-          .type = _Flags::_Type::__binary_lower_case},
-         1, CSTR("b}"));
-    test({.type = _Flags::_Type::__char}, 1, CSTR("c}"));
-    test({.alignment = _Flags::_Alignment::__right,
-          .type = _Flags::_Type::__decimal},
-         1, CSTR("d}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("e}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("f}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("g}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("h}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("i}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("j}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("k}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("l}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("m}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("n}"));
-    test({.alignment = _Flags::_Alignment::__right,
-          .type = _Flags::_Type::__octal},
-         1, CSTR("o}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("p}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("q}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("r}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("s}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("t}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("u}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("v}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("w}"));
-    test({.alignment = _Flags::_Alignment::__right,
-          .type = _Flags::_Type::__hexadecimal_lower_case},
-         1, CSTR("x}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("y}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("z}"));
-  }
-
-  // **** General ***
-  test_exception<Parser<CharT>>(
-      "The format-spec should consume the input or end with a '}'", CSTR("ss"));
-}
-
-constexpr bool test() {
-  test<char>();
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  test<wchar_t>();
-#endif
-
-  return true;
-}
-
-int main(int, char**) {
-#ifndef _WIN32
-  // TODO FMT Investigate why this doesn't work.
-  // (Wait until LWG-3576 has been resolved.)
-  // Make sure the parsers match the expectations. The layout of the
-  // subobjects is chosen to minimize the size required.
-  static_assert(sizeof(Parser<char>) == 2 * sizeof(uint32_t));
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  static_assert(
-      sizeof(Parser<wchar_t>) ==
-      (sizeof(wchar_t) <= 2 ? 2 * sizeof(uint32_t) : 3 * sizeof(uint32_t)));
-#endif
-#endif // _WIN32
-
-  test();
-  static_assert(test());
-
-  return 0;
-}

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_floating_point.pass.cpp

-//===----------------------------------------------------------------------===//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-has-no-incomplete-format
-
-// <format>
-
-// Tests the parsing of the format string as specified in [format.string.std].
-// It validates whether the std-format-spec is valid for a floating-point type.
-
-#include <format>
-#include <cassert>
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
-#  include <iostream>
-#endif
-
-#include "concepts_precision.h"
-#include "test_macros.h"
-#include "make_string.h"
-#include "test_exception.h"
-
-#define CSTR(S) MAKE_CSTRING(CharT, S)
-
-using namespace std::__format_spec;
-
-template <class CharT>
-using Parser = __parser_floating_point<CharT>;
-
-template <class CharT>
-struct Expected {
-  CharT fill = CharT(' ');
-  _Flags::_Alignment alignment = _Flags::_Alignment::__right;
-  _Flags::_Sign sign = _Flags::_Sign::__default;
-  bool alternate_form = false;
-  bool zero_padding = false;
-  uint32_t width = 0;
-  bool width_as_arg = false;
-  uint32_t precision = std::__format::__number_max;
-  bool precision_as_arg = true;
-  bool locale_specific_form = false;
-  _Flags::_Type type = _Flags::_Type::__default;
-};
-
-template <class CharT>
-constexpr void test(Expected<CharT> expected, size_t size, std::basic_string_view<CharT> fmt) {
-  // Initialize parser with sufficient arguments to avoid the parsing to fail
-  // due to insufficient arguments.
-  std::basic_format_parse_context<CharT> parse_ctx(fmt, std::__format::__number_max);
-  auto begin = parse_ctx.begin();
-  auto end = parse_ctx.end();
-  Parser<CharT> parser;
-  auto it = parser.parse(parse_ctx);
-
-  assert(begin == parse_ctx.begin());
-  assert(end == parse_ctx.end());
-
-  assert(begin + size == it);
-  assert(parser.__fill == expected.fill);
-  assert(parser.__alignment == expected.alignment);
-  assert(parser.__sign == expected.sign);
-  assert(parser.__alternate_form == expected.alternate_form);
-  assert(parser.__zero_padding == expected.zero_padding);
-  assert(parser.__width == expected.width);
-  assert(parser.__width_as_arg == expected.width_as_arg);
-  assert(parser.__precision == expected.precision);
-  assert(parser.__precision_as_arg == expected.precision_as_arg);
-  assert(parser.__locale_specific_form == expected.locale_specific_form);
-  assert(parser.__type == expected.type);
-}
-
-template <class CharT>
-constexpr void test(Expected<CharT> expected, size_t size, const CharT* f) {
-  // The format-spec is valid if completely consumed or terminates at a '}'.
-  // The valid inputs all end with a '}'. The test is executed twice:
-  // - first with the terminating '}',
-  // - second consuming the entire input.
-  std::basic_string_view<CharT> fmt{f};
-  assert(fmt.back() == CharT('}') && "Pre-condition failure");
-
-  test(expected, size, fmt);
-  fmt.remove_suffix(1);
-  test(expected, size, fmt);
-}
-
-template <class CharT>
-constexpr void test() {
-  Parser<CharT> parser;
-
-  assert(parser.__fill == CharT(' '));
-  assert(parser.__alignment == _Flags::_Alignment::__default);
-  assert(parser.__sign == _Flags::_Sign::__default);
-  assert(parser.__alternate_form == false);
-  assert(parser.__zero_padding == false);
-  assert(parser.__width == 0);
-  assert(parser.__width_as_arg == false);
-  assert(parser.__precision == std::__format::__number_max);
-  assert(parser.__precision_as_arg == true);
-  assert(parser.__locale_specific_form == false);
-  assert(parser.__type == _Flags::_Type::__default);
-
-  // Depending on whether or not a precision is specified the results differ.
-  // Table 65: Meaning of type options for floating-point types [tab:format.type.float]
-
-  test({}, 0, CSTR("}"));
-  test({.precision = 0, .precision_as_arg = false, .type = _Flags::_Type::__general_lower_case}, 2, CSTR(".0}"));
-  test({.precision = 1, .precision_as_arg = true, .type = _Flags::_Type::__general_lower_case}, 4, CSTR(".{1}}"));
-
-  test({.type = _Flags::_Type::__float_hexadecimal_lower_case}, 1, CSTR("a}"));
-  test({.type = _Flags::_Type::__float_hexadecimal_upper_case}, 1, CSTR("A}"));
-
-  test({.precision = 6, .precision_as_arg = false, .type = _Flags::_Type::__scientific_lower_case}, 1, CSTR("e}"));
-  test({.precision = 0, .precision_as_arg = false, .type = _Flags::_Type::__scientific_lower_case}, 3, CSTR(".0e}"));
-  test({.precision = 1, .precision_as_arg = true, .type = _Flags::_Type::__scientific_lower_case}, 5, CSTR(".{1}e}"));
-  test({.precision = 6, .precision_as_arg = false, .type = _Flags::_Type::__scientific_upper_case}, 1, CSTR("E}"));
-  test({.precision = 0, .precision_as_arg = false, .type = _Flags::_Type::__scientific_upper_case}, 3, CSTR(".0E}"));
-  test({.precision = 1, .precision_as_arg = true, .type = _Flags::_Type::__scientific_upper_case}, 5, CSTR(".{1}E}"));
-
-  test({.precision = 6, .precision_as_arg = false, .type = _Flags::_Type::__fixed_lower_case}, 1, CSTR("f}"));
-  test({.precision = 0, .precision_as_arg = false, .type = _Flags::_Type::__fixed_lower_case}, 3, CSTR(".0f}"));
-  test({.precision = 1, .precision_as_arg = true, .type = _Flags::_Type::__fixed_lower_case}, 5, CSTR(".{1}f}"));
-  test({.precision = 6, .precision_as_arg = false, .type = _Flags::_Type::__fixed_upper_case}, 1, CSTR("F}"));
-  test({.precision = 0, .precision_as_arg = false, .type = _Flags::_Type::__fixed_upper_case}, 3, CSTR(".0F}"));
-  test({.precision = 1, .precision_as_arg = true, .type = _Flags::_Type::__fixed_upper_case}, 5, CSTR(".{1}F}"));
-
-  test({.precision = 6, .precision_as_arg = false, .type = _Flags::_Type::__general_lower_case}, 1, CSTR("g}"));
-  test({.precision = 0, .precision_as_arg = false, .type = _Flags::_Type::__general_lower_case}, 3, CSTR(".0g}"));
-  test({.precision = 1, .precision_as_arg = true, .type = _Flags::_Type::__general_lower_case}, 5, CSTR(".{1}g}"));
-  test({.precision = 6, .precision_as_arg = false, .type = _Flags::_Type::__general_upper_case}, 1, CSTR("G}"));
-  test({.precision = 0, .precision_as_arg = false, .type = _Flags::_Type::__general_upper_case}, 3, CSTR(".0G}"));
-  test({.precision = 1, .precision_as_arg = true, .type = _Flags::_Type::__general_upper_case}, 5, CSTR(".{1}G}"));
-
-  // *** Align-fill ***
-  test({.alignment = _Flags::_Alignment::__left}, 1, CSTR("<}"));
-  test({.alignment = _Flags::_Alignment::__center}, 1, "^}");
-  test({.alignment = _Flags::_Alignment::__right}, 1, ">}");
-
-  test({.fill = CharT('L'), .alignment = _Flags::_Alignment::__left}, 2, CSTR("L<}"));
-  test({.fill = CharT('#'), .alignment = _Flags::_Alignment::__center}, 2, CSTR("#^}"));
-  test({.fill = CharT('0'), .alignment = _Flags::_Alignment::__right}, 2, CSTR("0>}"));
-
-  test_exception<Parser<CharT>>("The format-spec fill field contains an invalid character", CSTR("{<"));
-  test_exception<Parser<CharT>>("The format-spec fill field contains an invalid character", CSTR("}<"));
-
-  // *** Sign ***
-  test({.sign = _Flags::_Sign::__minus}, 1, CSTR("-}"));
-  test({.sign = _Flags::_Sign::__plus}, 1, CSTR("+}"));
-  test({.sign = _Flags::_Sign::__space}, 1, CSTR(" }"));
-
-  // *** Alternate form ***
-  test({.alternate_form = true}, 1, CSTR("#}"));
-
-  // *** Zero padding ***
-  // TODO FMT What to do with zero-padding without a width?
-  // [format.string.std]/13
-  //   A zero (0) character preceding the width field pads the field with
-  //   leading zeros (following any indication of sign or base) to the field
-  //   width, except when applied to an infinity or NaN.
-  // Obviously it makes no sense, but should it be allowed or is it a format
-  // error?
-  test({.alignment = _Flags::_Alignment::__default, .zero_padding = true}, 1, CSTR("0}"));
-  test({.alignment = _Flags::_Alignment::__left, .zero_padding = false}, 2, CSTR("<0}"));
-  test({.alignment = _Flags::_Alignment::__center, .zero_padding = false}, 2, CSTR("^0}"));
-  test({.alignment = _Flags::_Alignment::__right, .zero_padding = false}, 2, CSTR(">0}"));
-
-  // *** Width ***
-  test({.width = 0, .width_as_arg = false}, 0, CSTR("}"));
-  test({.width = 1, .width_as_arg = false}, 1, CSTR("1}"));
-  test({.width = 10, .width_as_arg = false}, 2, CSTR("10}"));
-  test({.width = 1000, .width_as_arg = false}, 4, CSTR("1000}"));
-  test({.width = 1000000, .width_as_arg = false}, 7, CSTR("1000000}"));
-
-  test({.width = 0, .width_as_arg = true}, 2, CSTR("{}}"));
-  test({.width = 0, .width_as_arg = true}, 3, CSTR("{0}}"));
-  test({.width = 1, .width_as_arg = true}, 3, CSTR("{1}}"));
-
-  test_exception<Parser<CharT>>("A format-spec width field shouldn't have a leading zero", CSTR("00"));
-
-  static_assert(std::__format::__number_max == 2'147'483'647, "Update the assert and the test.");
-  test({.width = 2'147'483'647, .width_as_arg = false}, 10, CSTR("2147483647}"));
-  test_exception<Parser<CharT>>("The numeric value of the format-spec is too large", CSTR("2147483648"));
-  test_exception<Parser<CharT>>("The numeric value of the format-spec is too large", CSTR("5000000000"));
-  test_exception<Parser<CharT>>("The numeric value of the format-spec is too large", CSTR("10000000000"));
-
-  test_exception<Parser<CharT>>("End of input while parsing format-spec arg-id", CSTR("{"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{0"));
-  test_exception<Parser<CharT>>("The arg-id of the format-spec starts with an invalid character", CSTR("{a"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{1"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{9"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{9:"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{9a"));
-  static_assert(std::__format::__number_max == 2'147'483'647, "Update the assert and the test.");
-  // Note the static_assert tests whether the arg-id is valid.
-  // Therefore the following should be true arg-id < __format::__number_max.
-  test({.width = 2'147'483'646, .width_as_arg = true}, 12, CSTR("{2147483646}}"));
-  test_exception<Parser<CharT>>("The numeric value of the format-spec is too large", CSTR("{2147483648}"));
-  test_exception<Parser<CharT>>("The numeric value of the format-spec is too large", CSTR("{5000000000}"));
-  test_exception<Parser<CharT>>("The numeric value of the format-spec is too large", CSTR("{10000000000}"));
-
-  // *** Precision ***
-  test({.precision = 0, .precision_as_arg = false, .type = _Flags::_Type::__general_lower_case}, 2, CSTR(".0}"));
-  test({.precision = 1, .precision_as_arg = false, .type = _Flags::_Type::__general_lower_case}, 2, CSTR(".1}"));
-  test({.precision = 10, .precision_as_arg = false, .type = _Flags::_Type::__general_lower_case}, 3, CSTR(".10}"));
-  test({.precision = 1000, .precision_as_arg = false, .type = _Flags::_Type::__general_lower_case}, 5, CSTR(".1000}"));
-  test({.precision = 1000000, .precision_as_arg = false, .type = _Flags::_Type::__general_lower_case}, 8,
-       CSTR(".1000000}"));
-
-  test({.precision = 0, .precision_as_arg = true, .type = _Flags::_Type::__general_lower_case}, 3, CSTR(".{}}"));
-  test({.precision = 0, .precision_as_arg = true, .type = _Flags::_Type::__general_lower_case}, 4, CSTR(".{0}}"));
-  test({.precision = 1, .precision_as_arg = true, .type = _Flags::_Type::__general_lower_case}, 4, CSTR(".{1}}"));
-
-  test_exception<Parser<CharT>>("The format-spec precision field doesn't contain a value or arg-id", CSTR(".a"));
-  test_exception<Parser<CharT>>("The format-spec precision field doesn't contain a value or arg-id", CSTR(".:"));
-
-  static_assert(std::__format::__number_max == 2'147'483'647, "Update the assert and the test.");
-  test({.precision = 2'147'483'647, .precision_as_arg = false, .type = _Flags::_Type::__general_lower_case}, 11,
-       CSTR(".2147483647}"));
-  test_exception<Parser<CharT>>("The numeric value of the format-spec is too large", CSTR(".2147483648"));
-  test_exception<Parser<CharT>>("The numeric value of the format-spec is too large", CSTR(".5000000000"));
-  test_exception<Parser<CharT>>("The numeric value of the format-spec is too large", CSTR(".10000000000"));
-
-  test_exception<Parser<CharT>>("End of input while parsing format-spec arg-id", CSTR(".{"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR(".{0"));
-  test_exception<Parser<CharT>>("The arg-id of the format-spec starts with an invalid character", CSTR(".{a"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR(".{1"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR(".{9"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR(".{9:"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR(".{9a"));
-
-  static_assert(std::__format::__number_max == 2'147'483'647, "Update the assert and the test.");
-  // Note the static_assert tests whether the arg-id is valid.
-  // Therefore the following should be true arg-id < __format::__number_max.
-  test({.precision = 2'147'483'646, .precision_as_arg = true, .type = _Flags::_Type::__general_lower_case}, 13,
-       CSTR(".{2147483646}}"));
-  test_exception<Parser<CharT>>("The numeric value of the format-spec is too large", CSTR(".{2147483648}"));
-  test_exception<Parser<CharT>>("The numeric value of the format-spec is too large", CSTR(".{5000000000}"));
-  test_exception<Parser<CharT>>("The numeric value of the format-spec is too large", CSTR(".{10000000000}"));
-
-  // *** Width & Precision ***
-  test({.width = 1,
-        .width_as_arg = false,
-        .precision = 0,
-        .precision_as_arg = false,
-        .type = _Flags::_Type::__general_lower_case},
-       3, CSTR("1.0}"));
-  test({.width = 0,
-        .width_as_arg = true,
-        .precision = 1,
-        .precision_as_arg = true,
-        .type = _Flags::_Type::__general_lower_case},
-       5, CSTR("{}.{}}"));
-  test({.width = 10,
-        .width_as_arg = true,
-        .precision = 9,
-        .precision_as_arg = true,
-        .type = _Flags::_Type::__general_lower_case},
-       8, CSTR("{10}.{9}}"));
-
-  // *** Locale-specific form ***
-  test({.locale_specific_form = true}, 1, CSTR("L}"));
-
-  // *** Type ***
-  {
-    const char* unsuported_type = "The format-spec type has a type not supported for a floating-point argument";
-    const char* not_a_type = "The format-spec should consume the input or end with a '}'";
-
-    test({.type = _Flags::_Type::__float_hexadecimal_upper_case}, 1, CSTR("A}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("B}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("C}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("D}"));
-    test({.precision = 6, .precision_as_arg = false, .type = _Flags::_Type::__scientific_upper_case}, 1, CSTR("E}"));
-    test({.precision = 6, .precision_as_arg = false, .type = _Flags::_Type::__fixed_upper_case}, 1, CSTR("F}"));
-    test({.precision = 6, .precision_as_arg = false, .type = _Flags::_Type::__general_upper_case}, 1, CSTR("G}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("H}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("I}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("J}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("K}"));
-    test({.locale_specific_form = true}, 1, CSTR("L}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("M}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("N}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("O}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("P}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("Q}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("R}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("S}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("T}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("U}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("V}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("W}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("X}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("Y}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("Z}"));
-
-    test({.type = _Flags::_Type::__float_hexadecimal_lower_case}, 1, CSTR("a}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("b}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("c}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("d}"));
-    test({.precision = 6, .precision_as_arg = false, .type = _Flags::_Type::__scientific_lower_case}, 1, CSTR("e}"));
-    test({.precision = 6, .precision_as_arg = false, .type = _Flags::_Type::__fixed_lower_case}, 1, CSTR("f}"));
-    test({.precision = 6, .precision_as_arg = false, .type = _Flags::_Type::__general_lower_case}, 1, CSTR("g}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("h}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("i}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("j}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("k}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("l}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("m}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("n}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("o}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("p}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("q}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("r}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("s}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("t}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("u}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("v}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("w}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("x}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("y}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("z}"));
-  }
-  // **** General ***
-  test_exception<Parser<CharT>>("The format-spec should consume the input or end with a '}'", CSTR("ss"));
-}
-
-constexpr bool test() {
-  test<char>();
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  test<wchar_t>();
-#endif
-
-  return true;
-}
-
-int main(int, char**) {
-#if !defined(_WIN32) && !defined(_AIX)
-  // Make sure the parsers match the expectations. The layout of the
-  // subobjects is chosen to minimize the size required.
-  static_assert(sizeof(Parser<char>) == 3 * sizeof(uint32_t));
-#  ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  static_assert(sizeof(Parser<wchar_t>) == (sizeof(wchar_t) <= 2 ? 3 * sizeof(uint32_t) : 4 * sizeof(uint32_t)));
-#  endif
-#endif
-
-  test();
-  static_assert(test());
-
-  return 0;
-}

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_integer.pass.cpp

-//===----------------------------------------------------------------------===//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-has-no-incomplete-format
-
-// <format>
-
-// Tests the parsing of the format string as specified in [format.string.std].
-// It validates whether the std-format-spec is valid for an integer type.
-
-#include <format>
-#include <cassert>
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
-# include <iostream>
-#endif
-
-#include "concepts_precision.h"
-#include "test_macros.h"
-#include "make_string.h"
-#include "test_exception.h"
-
-#define CSTR(S) MAKE_CSTRING(CharT, S)
-
-using namespace std::__format_spec;
-
-template <class CharT>
-using Parser = __parser_integer<CharT>;
-
-template <class CharT>
-struct Expected {
-  CharT fill = CharT(' ');
-  _Flags::_Alignment alignment = _Flags::_Alignment::__right;
-  _Flags::_Sign sign = _Flags::_Sign::__default;
-  bool alternate_form = false;
-  bool zero_padding = false;
-  uint32_t width = 0;
-  bool width_as_arg = false;
-  bool locale_specific_form = false;
-  _Flags::_Type type = _Flags::_Type::__decimal;
-};
-
-template <class CharT>
-constexpr void test(Expected<CharT> expected, size_t size,
-                    std::basic_string_view<CharT> fmt) {
-  // Initialize parser with sufficient arguments to avoid the parsing to fail
-  // due to insufficient arguments.
-  std::basic_format_parse_context<CharT> parse_ctx(fmt,
-                                                   std::__format::__number_max);
-  auto begin = parse_ctx.begin();
-  auto end = parse_ctx.end();
-  Parser<CharT> parser;
-  auto it = parser.parse(parse_ctx);
-
-  assert(begin == parse_ctx.begin());
-  assert(end == parse_ctx.end());
-
-  assert(begin + size == it);
-  assert(parser.__fill == expected.fill);
-  assert(parser.__alignment == expected.alignment);
-  assert(parser.__sign == expected.sign);
-  assert(parser.__alternate_form == expected.alternate_form);
-  assert(parser.__zero_padding == expected.zero_padding);
-  assert(parser.__width == expected.width);
-  assert(parser.__width_as_arg == expected.width_as_arg);
-  assert(parser.__locale_specific_form == expected.locale_specific_form);
-  assert(parser.__type == expected.type);
-}
-
-template <class CharT>
-constexpr void test(Expected<CharT> expected, size_t size, const CharT* f) {
-  // The format-spec is valid if completely consumed or terminates at a '}'.
-  // The valid inputs all end with a '}'. The test is executed twice:
-  // - first with the terminating '}',
-  // - second consuming the entire input.
-  std::basic_string_view<CharT> fmt{f};
-  assert(fmt.back() == CharT('}') && "Pre-condition failure");
-
-  test(expected, size, fmt);
-  fmt.remove_suffix(1);
-  test(expected, size, fmt);
-}
-
-template <class CharT>
-constexpr void test() {
-  Parser<CharT> parser;
-
-  assert(parser.__fill == CharT(' '));
-  assert(parser.__alignment == _Flags::_Alignment::__default);
-  assert(parser.__sign == _Flags::_Sign::__default);
-  assert(parser.__alternate_form == false);
-  assert(parser.__zero_padding == false);
-  assert(parser.__width == 0);
-  assert(parser.__width_as_arg == false);
-  static_assert(!has_precision<decltype(parser)>);
-  static_assert(!has_precision_as_arg<decltype(parser)>);
-  assert(parser.__locale_specific_form == false);
-  assert(parser.__type == _Flags::_Type::__default);
-
-  test({}, 0, CSTR("}"));
-  test({}, 1, CSTR("d}"));
-  test({.alignment = _Flags::_Alignment::__left, .type = _Flags::_Type::__char},
-       1, CSTR("c}"));
-
-  // *** Align-fill ***
-  test({.alignment = _Flags::_Alignment::__left}, 1, CSTR("<}"));
-  test({.alignment = _Flags::_Alignment::__center}, 1, "^}");
-  test({.alignment = _Flags::_Alignment::__right}, 1, ">}");
-
-  test({.fill = CharT('L'), .alignment = _Flags::_Alignment::__left}, 2,
-       CSTR("L<}"));
-  test({.fill = CharT('#'), .alignment = _Flags::_Alignment::__center}, 2,
-       CSTR("#^}"));
-  test({.fill = CharT('0'), .alignment = _Flags::_Alignment::__right}, 2,
-       CSTR("0>}"));
-
-  test_exception<Parser<CharT>>(
-      "The format-spec fill field contains an invalid character", CSTR("{<"));
-  test_exception<Parser<CharT>>(
-      "The format-spec fill field contains an invalid character", CSTR("}<"));
-
-  // *** Sign ***
-  test({.sign = _Flags::_Sign::__minus}, 1, CSTR("-}"));
-  test({.sign = _Flags::_Sign::__plus}, 1, CSTR("+}"));
-  test({.sign = _Flags::_Sign::__space}, 1, CSTR(" }"));
-
-  test({.sign = _Flags::_Sign::__minus}, 2, CSTR("-d}"));
-  test({.sign = _Flags::_Sign::__plus}, 2, CSTR("+d}"));
-  test({.sign = _Flags::_Sign::__space}, 2, CSTR(" d}"));
-
-  test_exception<Parser<CharT>>(
-      "A sign field isn't allowed in this format-spec", CSTR("-c"));
-  test_exception<Parser<CharT>>(
-      "A sign field isn't allowed in this format-spec", CSTR("+c"));
-  test_exception<Parser<CharT>>(
-      "A sign field isn't allowed in this format-spec", CSTR(" c"));
-
-  // *** Alternate form ***
-  test({.alternate_form = true}, 1, CSTR("#}"));
-  test({.alternate_form = true}, 2, CSTR("#d}"));
-  test_exception<Parser<CharT>>(
-      "An alternate form field isn't allowed in this format-spec", CSTR("#c"));
-
-  // *** Zero padding ***
-  // TODO FMT What to do with zero-padding without a width?
-  // [format.string.std]/13
-  //   A zero (0) character preceding the width field pads the field with
-  //   leading zeros (following any indication of sign or base) to the field
-  //   width, except when applied to an infinity or NaN.
-  // Obviously it makes no sense, but should it be allowed or is it a format
-  // errror?
-  test({.alignment = _Flags::_Alignment::__default, .zero_padding = true}, 1,
-       CSTR("0}"));
-  test({.alignment = _Flags::_Alignment::__left, .zero_padding = false}, 2,
-       CSTR("<0}"));
-  test({.alignment = _Flags::_Alignment::__center, .zero_padding = false}, 2,
-       CSTR("^0}"));
-  test({.alignment = _Flags::_Alignment::__right, .zero_padding = false}, 2,
-       CSTR(">0}"));
-
-  test({.alignment = _Flags::_Alignment::__default, .zero_padding = true}, 2,
-       CSTR("0d}"));
-  test({.alignment = _Flags::_Alignment::__left, .zero_padding = false}, 3,
-       CSTR("<0d}"));
-  test({.alignment = _Flags::_Alignment::__center, .zero_padding = false}, 3,
-       CSTR("^0d}"));
-  test({.alignment = _Flags::_Alignment::__right, .zero_padding = false}, 3,
-       CSTR(">0d}"));
-
-  test_exception<Parser<CharT>>(
-      "A zero-padding field isn't allowed in this format-spec", CSTR("0c"));
-  test_exception<Parser<CharT>>(
-      "A zero-padding field isn't allowed in this format-spec", CSTR("<0c"));
-  test_exception<Parser<CharT>>(
-      "A zero-padding field isn't allowed in this format-spec", CSTR("^0c"));
-  test_exception<Parser<CharT>>(
-      "A zero-padding field isn't allowed in this format-spec", CSTR(">0c"));
-
-  // *** Width ***
-  test({.width = 0, .width_as_arg = false}, 0, CSTR("}"));
-  test({.width = 1, .width_as_arg = false}, 1, CSTR("1}"));
-  test({.width = 10, .width_as_arg = false}, 2, CSTR("10}"));
-  test({.width = 1000, .width_as_arg = false}, 4, CSTR("1000}"));
-  test({.width = 1000000, .width_as_arg = false}, 7, CSTR("1000000}"));
-
-  test({.width = 0, .width_as_arg = true}, 2, CSTR("{}}"));
-  test({.width = 0, .width_as_arg = true}, 3, CSTR("{0}}"));
-  test({.width = 1, .width_as_arg = true}, 3, CSTR("{1}}"));
-
-  test_exception<Parser<CharT>>(
-      "A format-spec width field shouldn't have a leading zero", CSTR("00"));
-
-  static_assert(std::__format::__number_max == 2'147'483'647,
-                "Update the assert and the test.");
-  test({.width = 2'147'483'647, .width_as_arg = false}, 10,
-       CSTR("2147483647}"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large", CSTR("2147483648"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large", CSTR("5000000000"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large", CSTR("10000000000"));
-
-  test_exception<Parser<CharT>>("End of input while parsing format-spec arg-id",
-                                CSTR("{"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{0"));
-  test_exception<Parser<CharT>>(
-      "The arg-id of the format-spec starts with an invalid character",
-      CSTR("{a"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{1"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{9"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{9:"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{9a"));
-
-  static_assert(std::__format::__number_max == 2'147'483'647,
-                "Update the assert and the test.");
-  // Note the static_assert tests whether the arg-id is valid.
-  // Therefore the following should be true arg-id < __format::__number_max.
-  test({.width = 2'147'483'646, .width_as_arg = true}, 12,
-       CSTR("{2147483646}}"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large",
-      CSTR("{2147483648}"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large",
-      CSTR("{5000000000}"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large",
-      CSTR("{10000000000}"));
-
-  // *** Precision ***
-  test_exception<Parser<CharT>>(
-      "The format-spec should consume the input or end with a '}'", CSTR("."));
-  test_exception<Parser<CharT>>(
-      "The format-spec should consume the input or end with a '}'", CSTR(".1"));
-
-  // *** Locale-specific form ***
-  test({.locale_specific_form = true}, 1, CSTR("L}"));
-  test({.locale_specific_form = true}, 2, CSTR("Ld}"));
-  // Note the flag is allowed, but has no effect.
-  test({.alignment = _Flags::_Alignment::__left,
-        .locale_specific_form = true,
-        .type = _Flags::_Type::__char},
-       2, CSTR("Lc}"));
-
-  // *** Type ***
-  {
-    const char* unsuported_type =
-        "The format-spec type has a type not supported for an integer argument";
-    const char* not_a_type =
-        "The format-spec should consume the input or end with a '}'";
-
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("A}"));
-    test({.type = _Flags::_Type::__binary_upper_case}, 1, CSTR("B}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("C}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("D}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("E}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("F}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("G}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("H}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("I}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("J}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("K}"));
-    test({.locale_specific_form = true}, 1, CSTR("L}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("M}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("N}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("O}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("P}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("Q}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("R}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("S}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("T}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("U}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("V}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("W}"));
-    test({.type = _Flags::_Type::__hexadecimal_upper_case}, 1, CSTR("X}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("Y}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("Z}"));
-
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("a}"));
-    test({.type = _Flags::_Type::__binary_lower_case}, 1, CSTR("b}"));
-    test({.alignment = _Flags::_Alignment::__left,
-          .type = _Flags::_Type::__char},
-         1, CSTR("c}"));
-    test({.type = _Flags::_Type::__decimal}, 1, CSTR("d}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("e}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("f}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("g}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("h}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("i}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("j}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("k}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("l}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("m}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("n}"));
-    test({.type = _Flags::_Type::__octal}, 1, CSTR("o}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("p}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("q}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("r}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("s}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("t}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("u}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("v}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("w}"));
-    test({.type = _Flags::_Type::__hexadecimal_lower_case}, 1, CSTR("x}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("y}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("z}"));
-  }
-  // **** General ***
-  test_exception<Parser<CharT>>(
-      "The format-spec should consume the input or end with a '}'", CSTR("ss"));
-}
-
-constexpr bool test() {
-  test<char>();
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  test<wchar_t>();
-#endif
-
-  return true;
-}
-
-int main(int, char**) {
-#ifndef _WIN32
-  // Make sure the parsers match the expectations. The layout of the
-  // subobjects is chosen to minimize the size required.
-  static_assert(sizeof(Parser<char>) == 2 * sizeof(uint32_t));
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  static_assert(
-      sizeof(Parser<wchar_t>) ==
-      (sizeof(wchar_t) <= 2 ? 2 * sizeof(uint32_t) : 3 * sizeof(uint32_t)));
-#endif
-#endif // _WIN32
-
-  test();
-  static_assert(test());
-
-  return 0;
-}

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_parser.pass.cpp

+//===----------------------------------------------------------------------===//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// <format>
+
+#include <format>
+#include <cassert>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class F>
+constexpr void check_exception(F&& f) {
+  if (std::is_constant_evaluated())
+    return;
+
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  try {
+    f();
+    assert(false);
+  } catch (std::format_error&) {
+    return;
+  }
+  assert(false);
+#else
+  (void)f;
+#endif
+}
+
+// Valiate the values of the default constructed fields and the provided named field selections.
+static_assert(std::__format_spec::__fields{}.__sign_ == false &&
+              std::__format_spec::__fields{}.__alternate_form_ == false &&
+              std::__format_spec::__fields{}.__zero_padding_ == false &&
+              std::__format_spec::__fields{}.__precision_ == false &&
+              std::__format_spec::__fields{}.__locale_specific_form_ == false);
+
+static_assert(std::__format_spec::__fields_integral.__sign_ == true &&
+              std::__format_spec::__fields_integral.__alternate_form_ == true &&
+              std::__format_spec::__fields_integral.__zero_padding_ == true &&
+              std::__format_spec::__fields_integral.__precision_ == false &&
+              std::__format_spec::__fields_integral.__locale_specific_form_ == true);
+
+static_assert(std::__format_spec::__fields_floating_point.__sign_ == true &&
+              std::__format_spec::__fields_floating_point.__alternate_form_ == true &&
+              std::__format_spec::__fields_floating_point.__zero_padding_ == true &&
+              std::__format_spec::__fields_floating_point.__precision_ == true &&
+              std::__format_spec::__fields_floating_point.__locale_specific_form_ == true);
+
+static_assert(std::__format_spec::__fields_pointer.__sign_ == false &&
+              std::__format_spec::__fields_pointer.__alternate_form_ == false &&
+              std::__format_spec::__fields_pointer.__zero_padding_ == false &&
+              std::__format_spec::__fields_pointer.__precision_ == false &&
+              std::__format_spec::__fields_pointer.__locale_specific_form_ == false);
+
+static_assert(std::__format_spec::__fields_string.__sign_ == false &&
+              std::__format_spec::__fields_string.__alternate_form_ == false &&
+              std::__format_spec::__fields_string.__zero_padding_ == false &&
+              std::__format_spec::__fields_string.__precision_ == true &&
+              std::__format_spec::__fields_string.__locale_specific_form_ == false);
+
+inline constexpr std::__format_spec::__fields all_fields{true, true, true, true, true};
+
+// A std::basic_format_parse_context needs a number of arguments.
+// This number is large enough for the parser not to fail on a lack of arguments.
+constexpr size_t num_args = 100;
+
+template <class CharT>
+constexpr void test_align_fill(std::__format_spec::__fields fields) {
+  {
+    std::__format_spec::__parser<CharT> parser;
+    assert(parser.__fill_ == CharT(' '));
+
+    std::basic_format_parse_context parse_ctx{SV(""), num_args};
+    parser.__parse(parse_ctx, fields);
+
+    assert(parser.__fill_ == CharT(' '));
+  }
+  {
+    std::__format_spec::__parser<CharT> parser;
+    assert(parser.__fill_ == CharT(' '));
+
+    std::basic_format_parse_context parse_ctx{SV("a<"), num_args};
+    parser.__parse(parse_ctx, fields);
+
+    assert(parser.__fill_ == CharT('a'));
+  }
+}
+
+template <class CharT>
+constexpr void test_align_fill() {
+  test_align_fill<CharT>(std::__format_spec::__fields{});
+  test_align_fill<CharT>(all_fields);
+}
+
+template <class CharT>
+constexpr void test_sign(std::__format_spec::__fields fields) {
+  {
+    std::__format_spec::__parser<CharT> parser;
+    assert(parser.__sign_ == std::__format_spec::__sign::__default);
+
+    std::basic_format_parse_context parse_ctx{SV(""), num_args};
+    parser.__parse(parse_ctx, fields);
+    assert(parser.__sign_ == std::__format_spec::__sign::__default);
+  }
+  {
+    std::__format_spec::__parser<CharT> parser;
+    assert(parser.__sign_ == std::__format_spec::__sign::__default);
+    {
+      std::basic_format_parse_context parse_ctx{SV("-"), num_args};
+      parser.__parse(parse_ctx, fields);
+      assert(parser.__sign_ == std::__format_spec::__sign::__minus);
+    }
+    {
+      std::basic_format_parse_context parse_ctx{SV("+"), num_args};
+      parser.__parse(parse_ctx, fields);
+      assert(parser.__sign_ == std::__format_spec::__sign::__plus);
+    }
+    {
+      std::basic_format_parse_context parse_ctx{SV(" "), num_args};
+      parser.__parse(parse_ctx, fields);
+      assert(parser.__sign_ == std::__format_spec::__sign::__space);
+    }
+  }
+}
+
+template <class CharT>
+constexpr void test_sign() {
+  test_sign<CharT>(std::__format_spec::__fields{.__sign_ = true});
+  test_sign<CharT>(all_fields);
+
+  {
+    std::__format_spec::__parser<CharT> parser;
+    std::basic_format_parse_context parse_ctx{SV(""), num_args};
+    parser.__parse(parse_ctx, std::__format_spec::__fields{.__sign_ = false});
+  }
+  check_exception([] {
+    std::__format_spec::__parser<CharT> parser;
+    std::basic_format_parse_context parse_ctx{SV("-"), num_args};
+    parser.__parse(parse_ctx, std::__format_spec::__fields{.__sign_ = false});
+  });
+}
+
+template <class CharT>
+constexpr void test_alternate_form(std::__format_spec::__fields fields) {
+  {
+    std::__format_spec::__parser<CharT> parser;
+    assert(parser.__alternate_form_ == false);
+
+    std::basic_format_parse_context parse_ctx{SV(""), num_args};
+    parser.__parse(parse_ctx, fields);
+    assert(parser.__alternate_form_ == false);
+  }
+  {
+    std::__format_spec::__parser<CharT> parser;
+
+    std::basic_format_parse_context parse_ctx{SV("#"), num_args};
+    parser.__parse(parse_ctx, fields);
+    assert(parser.__alternate_form_ == true);
+  }
+}
+
+template <class CharT>
+constexpr void test_alternate_form() {
+  test_alternate_form<CharT>(std::__format_spec::__fields{.__alternate_form_ = true});
+  test_alternate_form<CharT>(all_fields);
+
+  {
+    std::__format_spec::__parser<CharT> parser;
+    std::basic_format_parse_context parse_ctx{SV(""), num_args};
+    parser.__parse(parse_ctx, std::__format_spec::__fields{.__alternate_form_ = false});
+  }
+  check_exception([] {
+    std::__format_spec::__parser<CharT> parser;
+    std::basic_format_parse_context parse_ctx{SV("#"), num_args};
+    parser.__parse(parse_ctx, std::__format_spec::__fields{.__alternate_form_ = false});
+  });
+}
+
+template <class CharT>
+constexpr void test_zero_padding(std::__format_spec::__fields fields) {
+  {
+    std::__format_spec::__parser<CharT> parser;
+    assert(parser.__zero_padding_ == false);
+
+    std::basic_format_parse_context parse_ctx{SV(""), num_args};
+    parser.__parse(parse_ctx, fields);
+    assert(parser.__zero_padding_ == false);
+  }
+  {
+    std::__format_spec::__parser<CharT> parser;
+
+    std::basic_format_parse_context parse_ctx{SV("0"), num_args};
+    parser.__parse(parse_ctx, fields);
+    assert(parser.__zero_padding_ == true);
+  }
+}
+
+template <class CharT>
+constexpr void test_zero_padding() {
+  test_zero_padding<CharT>(std::__format_spec::__fields{.__zero_padding_ = true});
+  test_zero_padding<CharT>(all_fields);
+
+  {
+    std::__format_spec::__parser<CharT> parser;
+    std::basic_format_parse_context parse_ctx{SV(""), num_args};
+    parser.__parse(parse_ctx, std::__format_spec::__fields{.__zero_padding_ = false});
+  }
+  check_exception([] {
+    std::__format_spec::__parser<CharT> parser;
+    std::basic_format_parse_context parse_ctx{SV("0"), num_args};
+    parser.__parse(parse_ctx, std::__format_spec::__fields{.__zero_padding_ = false});
+  });
+}
+
+template <class CharT>
+constexpr void test_width(std::__format_spec::__fields fields) {
+  // XXX test limits int32_max
+  {
+    std::__format_spec::__parser<CharT> parser;
+    assert(!parser.__has_width());
+    assert(!parser.__width_as_arg_);
+    assert(parser.__width_ == 0);
+  }
+  {
+    std::__format_spec::__parser<CharT> parser;
+    std::basic_format_parse_context parse_ctx{SV("1"), num_args};
+    parser.__parse(parse_ctx, fields);
+
+    assert(parser.__zero_padding_ == false);
+    assert(parser.__has_width());
+    assert(!parser.__width_as_arg_);
+    assert(parser.__width_ == 1);
+  }
+  if (fields.__zero_padding_) {
+    std::__format_spec::__parser<CharT> parser;
+    std::basic_format_parse_context parse_ctx{SV("09"), num_args};
+    parser.__parse(parse_ctx, fields);
+
+    assert(parser.__zero_padding_ == true);
+    assert(parser.__has_width());
+    assert(!parser.__width_as_arg_);
+    assert(parser.__width_ == 9);
+  }
+  if (fields.__zero_padding_)
+    check_exception([fields] {
+      std::__format_spec::__parser<CharT> parser;
+      std::basic_format_parse_context parse_ctx{SV("00"), num_args};
+      parser.__parse(parse_ctx, fields);
+    });
+  else
+    check_exception([fields] {
+      std::__format_spec::__parser<CharT> parser;
+      std::basic_format_parse_context parse_ctx{SV("0"), num_args};
+      parser.__parse(parse_ctx, fields);
+    });
+  {
+    std::__format_spec::__parser<CharT> parser;
+    std::basic_format_parse_context parse_ctx{SV("{}"), num_args};
+    parser.__parse(parse_ctx, fields);
+
+    assert(parser.__width_as_arg_);
+    assert(parser.__width_ == 0);
+  }
+  {
+    std::__format_spec::__parser<CharT> parser;
+    std::basic_format_parse_context parse_ctx{SV("{42}"), 43};
+    parser.__parse(parse_ctx, fields);
+
+    assert(parser.__width_as_arg_);
+    assert(parser.__width_ == 42);
+  }
+}
+
+template <class CharT>
+constexpr void test_width() {
+  test_width<CharT>(std::__format_spec::__fields{});
+  test_width<CharT>(all_fields);
+}
+
+template <class CharT>
+constexpr void test_precision(std::__format_spec::__fields fields) {
+  // XXX test limits int32_max
+  {
+    std::__format_spec::__parser<CharT> parser;
+    assert(!parser.__has_precision());
+    assert(!parser.__precision_as_arg_);
+    LIBCPP_ASSERT(parser.__precision_ == -1 /*std::__format::__number_max*/);
+  }
+  {
+    std::__format_spec::__parser<CharT> parser;
+    std::basic_format_parse_context parse_ctx{SV(".0"), num_args};
+    parser.__parse(parse_ctx, fields);
+
+    assert(parser.__has_precision());
+    assert(!parser.__precision_as_arg_);
+    assert(parser.__precision_ == 0);
+  }
+  {
+    std::__format_spec::__parser<CharT> parser;
+    std::basic_format_parse_context parse_ctx{SV(".{}"), num_args};
+    parser.__parse(parse_ctx, fields);
+
+    assert(parser.__precision_as_arg_);
+    assert(parser.__precision_ == 0);
+    /*
+    parser.__set_precision(42);
+    assert(parser.__has_precision());
+    assert(!parser.__precision_as_arg_);
+    assert(parser.__precision_ == 42);*/
+  }
+  {
+    std::__format_spec::__parser<CharT> parser;
+    std::basic_format_parse_context parse_ctx{SV("{}.{}"), num_args};
+    parser.__parse(parse_ctx, fields);
+
+    assert(parser.__width_as_arg_);
+    assert(parser.__width_ == 0);
+
+    assert(parser.__precision_as_arg_);
+    assert(parser.__precision_ == 1);
+  }
+  {
+    std::__format_spec::__parser<CharT> parser;
+    std::basic_format_parse_context parse_ctx{SV(".{42}"), num_args};
+    parser.__parse(parse_ctx, fields);
+
+    assert(parser.__precision_as_arg_);
+    assert(parser.__precision_ == 42);
+  }
+}
+
+template <class CharT>
+constexpr void test_precision() {
+  test_precision<CharT>(std::__format_spec::__fields{.__precision_ = true});
+  test_precision<CharT>(all_fields);
+
+  {
+    std::__format_spec::__parser<CharT> parser;
+    std::basic_format_parse_context parse_ctx{SV(""), num_args};
+    parser.__parse(parse_ctx, std::__format_spec::__fields{.__precision_ = false});
+  }
+  check_exception([] {
+    std::__format_spec::__parser<CharT> parser;
+    std::basic_format_parse_context parse_ctx{SV(".1"), num_args};
+    parser.__parse(parse_ctx, std::__format_spec::__fields{.__precision_ = false});
+  });
+}
+
+template <class CharT>
+constexpr void test_locale_specific_form(std::__format_spec::__fields fields) {
+  {
+    std::__format_spec::__parser<CharT> parser;
+    std::basic_format_parse_context parse_ctx{SV(""), num_args};
+    parser.__parse(parse_ctx, fields);
+
+    assert(parser.__locale_specific_form_ == false);
+  }
+  {
+    std::__format_spec::__parser<CharT> parser;
+    std::basic_format_parse_context parse_ctx{SV("L"), num_args};
+    parser.__parse(parse_ctx, fields);
+
+    assert(parser.__locale_specific_form_ == true);
+  }
+}
+
+template <class CharT>
+constexpr void test_locale_specific_form() {
+  test_locale_specific_form<CharT>(std::__format_spec::__fields{.__locale_specific_form_ = true});
+  test_locale_specific_form<CharT>(all_fields);
+
+  {
+    std::__format_spec::__parser<CharT> parser;
+    std::basic_format_parse_context parse_ctx{SV(""), num_args};
+    parser.__parse(parse_ctx, std::__format_spec::__fields{.__locale_specific_form_ = false});
+  }
+  check_exception([] {
+    std::__format_spec::__parser<CharT> parser;
+    std::basic_format_parse_context parse_ctx{SV("L"), num_args};
+    parser.__parse(parse_ctx, std::__format_spec::__fields{.__locale_specific_form_ = false});
+  });
+}
+
+template <class CharT>
+constexpr void test_type(std::__format_spec::__fields fields) {
+  {
+    std::__format_spec::__parser<CharT> parser;
+    assert(parser.__type_ == std::__format_spec::__type::__default);
+
+    std::basic_format_parse_context parse_ctx{SV(""), num_args};
+    parser.__parse(parse_ctx, fields);
+    assert(parser.__type_ == std::__format_spec::__type::__default);
+  }
+  {
+    std::__format_spec::__parser<CharT> parser;
+    assert(parser.__type_ == std::__format_spec::__type::__default);
+    {
+      std::basic_format_parse_context parse_ctx{SV("a"), num_args};
+      parser.__parse(parse_ctx, fields);
+      assert(parser.__type_ == std::__format_spec::__type::__float_hexadecimal_lower_case);
+    }
+    {
+      std::basic_format_parse_context parse_ctx{SV("A"), num_args};
+      parser.__parse(parse_ctx, fields);
+      assert(parser.__type_ == std::__format_spec::__type::__float_hexadecimal_upper_case);
+    }
+    {
+      std::basic_format_parse_context parse_ctx{SV("b"), num_args};
+      parser.__parse(parse_ctx, fields);
+      assert(parser.__type_ == std::__format_spec::__type::__binary_lower_case);
+    }
+    {
+      std::basic_format_parse_context parse_ctx{SV("B"), num_args};
+      parser.__parse(parse_ctx, fields);
+      assert(parser.__type_ == std::__format_spec::__type::__binary_upper_case);
+    }
+    {
+      std::basic_format_parse_context parse_ctx{SV("c"), num_args};
+      parser.__parse(parse_ctx, fields);
+      assert(parser.__type_ == std::__format_spec::__type::__char);
+    }
+    {
+      std::basic_format_parse_context parse_ctx{SV("d"), num_args};
+      parser.__parse(parse_ctx, fields);
+      assert(parser.__type_ == std::__format_spec::__type::__decimal);
+    }
+    {
+      std::basic_format_parse_context parse_ctx{SV("e"), num_args};
+      parser.__parse(parse_ctx, fields);
+      assert(parser.__type_ == std::__format_spec::__type::__scientific_lower_case);
+    }
+    {
+      std::basic_format_parse_context parse_ctx{SV("E"), num_args};
+      parser.__parse(parse_ctx, fields);
+      assert(parser.__type_ == std::__format_spec::__type::__scientific_upper_case);
+    }
+    {
+      std::basic_format_parse_context parse_ctx{SV("f"), num_args};
+      parser.__parse(parse_ctx, fields);
+      assert(parser.__type_ == std::__format_spec::__type::__fixed_lower_case);
+    }
+    {
+      std::basic_format_parse_context parse_ctx{SV("F"), num_args};
+      parser.__parse(parse_ctx, fields);
+      assert(parser.__type_ == std::__format_spec::__type::__fixed_upper_case);
+    }
+    {
+      std::basic_format_parse_context parse_ctx{SV("g"), num_args};
+      parser.__parse(parse_ctx, fields);
+      assert(parser.__type_ == std::__format_spec::__type::__general_lower_case);
+    }
+    {
+      std::basic_format_parse_context parse_ctx{SV("G"), num_args};
+      parser.__parse(parse_ctx, fields);
+      assert(parser.__type_ == std::__format_spec::__type::__general_upper_case);
+    }
+    {
+      std::basic_format_parse_context parse_ctx{SV("o"), num_args};
+      parser.__parse(parse_ctx, fields);
+      assert(parser.__type_ == std::__format_spec::__type::__octal);
+    }
+    {
+      std::basic_format_parse_context parse_ctx{SV("p"), num_args};
+      parser.__parse(parse_ctx, fields);
+      assert(parser.__type_ == std::__format_spec::__type::__pointer);
+    }
+    {
+      std::basic_format_parse_context parse_ctx{SV("s"), num_args};
+      parser.__parse(parse_ctx, fields);
+      assert(parser.__type_ == std::__format_spec::__type::__string);
+    }
+    {
+      std::basic_format_parse_context parse_ctx{SV("x"), num_args};
+      parser.__parse(parse_ctx, fields);
+      assert(parser.__type_ == std::__format_spec::__type::__hexadecimal_lower_case);
+    }
+    {
+      std::basic_format_parse_context parse_ctx{SV("X"), num_args};
+      parser.__parse(parse_ctx, fields);
+      assert(parser.__type_ == std::__format_spec::__type::__hexadecimal_upper_case);
+    }
+  }
+}
+
+template <class CharT>
+constexpr void test_type() {
+  test_type<CharT>(std::__format_spec::__fields{});
+  test_type<CharT>(all_fields);
+}
+
+template <class CharT>
+constexpr void test() {
+
+  test_align_fill<CharT>();
+  test_sign<CharT>();
+  test_alternate_form<CharT>();
+  test_zero_padding<CharT>();
+
+  test_width<CharT>();
+  test_precision<CharT>();
+  test_locale_specific_form<CharT>();
+  test_type<CharT>();
+
+  // The parser should fit in 128-bit allowing it to be passed in the registers on 64-bit platforms.
+  static_assert(sizeof(std::__format_spec::__parser<CharT>) == 2 * sizeof(int64_t));
+  static_assert(std::is_trivially_copyable_v<std::__format_spec::__parser<CharT>>);
+}
+
+constexpr bool test() {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_pointer.pass.cpp

-//===----------------------------------------------------------------------===//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-has-no-incomplete-format
-
-// <format>
-
-// Tests the parsing of the format string as specified in [format.string.std].
-// It validates whether the std-format-spec is valid for a pointer type.
-
-#include <format>
-#include <cassert>
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
-#  include <iostream>
-#endif
-
-#include "concepts_precision.h"
-#include "test_macros.h"
-#include "make_string.h"
-#include "test_exception.h"
-
-#define CSTR(S) MAKE_CSTRING(CharT, S)
-
-using namespace std::__format_spec;
-
-template <class CharT>
-using Parser = __parser_pointer<CharT>;
-
-template <class CharT>
-struct Expected {
-  CharT fill = CharT(' ');
-  _Flags::_Alignment alignment = _Flags::_Alignment::__right;
-  _Flags::_Sign sign = _Flags::_Sign::__default;
-  bool alternate_form = false;
-  bool zero_padding = false;
-  uint32_t width = 0;
-  bool width_as_arg = false;
-  bool locale_specific_form = false;
-  _Flags::_Type type = _Flags::_Type::__pointer;
-};
-
-template <class CharT>
-constexpr void test(Expected<CharT> expected, size_t size, std::basic_string_view<CharT> fmt) {
-  // Initialize parser with sufficient arguments to avoid the parsing to fail
-  // due to insufficient arguments.
-  std::basic_format_parse_context<CharT> parse_ctx(fmt, std::__format::__number_max);
-  auto begin = parse_ctx.begin();
-  auto end = parse_ctx.end();
-  Parser<CharT> parser;
-  auto it = parser.parse(parse_ctx);
-
-  assert(begin == parse_ctx.begin());
-  assert(end == parse_ctx.end());
-
-  assert(begin + size == it);
-  assert(parser.__fill == expected.fill);
-  assert(parser.__alignment == expected.alignment);
-  assert(parser.__sign == expected.sign);
-  assert(parser.__alternate_form == expected.alternate_form);
-  assert(parser.__zero_padding == expected.zero_padding);
-  assert(parser.__width == expected.width);
-  assert(parser.__width_as_arg == expected.width_as_arg);
-  assert(parser.__locale_specific_form == expected.locale_specific_form);
-  assert(parser.__type == expected.type);
-}
-
-template <class CharT>
-constexpr void test(Expected<CharT> expected, size_t size, const CharT* f) {
-  // The format-spec is valid if completely consumed or terminates at a '}'.
-  // The valid inputs all end with a '}'. The test is executed twice:
-  // - first with the terminating '}',
-  // - second consuming the entire input.
-  std::basic_string_view<CharT> fmt{f};
-  assert(fmt.back() == CharT('}') && "Pre-condition failure");
-
-  test(expected, size, fmt);
-  fmt.remove_suffix(1);
-  test(expected, size, fmt);
-}
-
-template <class CharT>
-constexpr void test() {
-  Parser<CharT> parser;
-
-  assert(parser.__fill == CharT(' '));
-  assert(parser.__alignment == _Flags::_Alignment::__right);
-  assert(parser.__sign == _Flags::_Sign::__default);
-  assert(parser.__alternate_form == false);
-  assert(parser.__zero_padding == false);
-  assert(parser.__width == 0);
-  assert(parser.__width_as_arg == false);
-  assert(parser.__locale_specific_form == false);
-  assert(parser.__type == _Flags::_Type::__default);
-
-  test({}, 0, CSTR("}"));
-
-  // *** Align-fill ***
-  test({.alignment = _Flags::_Alignment::__left}, 1, CSTR("<}"));
-  test({.alignment = _Flags::_Alignment::__center}, 1, "^}");
-  test({.alignment = _Flags::_Alignment::__right}, 1, ">}");
-
-  test({.fill = CharT('L'), .alignment = _Flags::_Alignment::__left}, 2, CSTR("L<}"));
-  test({.fill = CharT('#'), .alignment = _Flags::_Alignment::__center}, 2, CSTR("#^}"));
-  test({.fill = CharT('0'), .alignment = _Flags::_Alignment::__right}, 2, CSTR("0>}"));
-
-  test_exception<Parser<CharT>>("The format-spec fill field contains an invalid character", CSTR("{<"));
-  test_exception<Parser<CharT>>("The format-spec fill field contains an invalid character", CSTR("}<"));
-
-  // *** Sign ***
-  test_exception<Parser<CharT>>("The format-spec should consume the input or end with a '}'", CSTR("+"));
-  test_exception<Parser<CharT>>("The format-spec should consume the input or end with a '}'", CSTR("-"));
-  test_exception<Parser<CharT>>("The format-spec should consume the input or end with a '}'", CSTR(" "));
-
-  // *** Alternate form ***
-  test_exception<Parser<CharT>>("The format-spec should consume the input or end with a '}'", CSTR("#"));
-
-  // *** Zero padding ***
-  test_exception<Parser<CharT>>("A format-spec width field shouldn't have a leading zero", CSTR("0"));
-
-  // *** Width ***
-  test({.width = 0, .width_as_arg = false}, 0, CSTR("}"));
-  test({.width = 1, .width_as_arg = false}, 1, CSTR("1}"));
-  test({.width = 10, .width_as_arg = false}, 2, CSTR("10}"));
-  test({.width = 1000, .width_as_arg = false}, 4, CSTR("1000}"));
-  test({.width = 1000000, .width_as_arg = false}, 7, CSTR("1000000}"));
-
-  test({.width = 0, .width_as_arg = true}, 2, CSTR("{}}"));
-  test({.width = 0, .width_as_arg = true}, 3, CSTR("{0}}"));
-  test({.width = 1, .width_as_arg = true}, 3, CSTR("{1}}"));
-
-  test_exception<Parser<CharT>>("A format-spec width field shouldn't have a leading zero", CSTR("00"));
-
-  static_assert(std::__format::__number_max == 2'147'483'647, "Update the assert and the test.");
-  test({.width = 2'147'483'647, .width_as_arg = false}, 10, CSTR("2147483647}"));
-  test_exception<Parser<CharT>>("The numeric value of the format-spec is too large", CSTR("2147483648"));
-  test_exception<Parser<CharT>>("The numeric value of the format-spec is too large", CSTR("5000000000"));
-  test_exception<Parser<CharT>>("The numeric value of the format-spec is too large", CSTR("10000000000"));
-
-  test_exception<Parser<CharT>>("End of input while parsing format-spec arg-id", CSTR("{"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{0"));
-  test_exception<Parser<CharT>>("The arg-id of the format-spec starts with an invalid character", CSTR("{a"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{1"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{9"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{9:"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{9a"));
-  static_assert(std::__format::__number_max == 2'147'483'647, "Update the assert and the test.");
-  // Note the static_assert tests whether the arg-id is valid.
-  // Therefore the following should be true arg-id < __format::__number_max.
-  test({.width = 2'147'483'646, .width_as_arg = true}, 12, CSTR("{2147483646}}"));
-  test_exception<Parser<CharT>>("The numeric value of the format-spec is too large", CSTR("{2147483648}"));
-  test_exception<Parser<CharT>>("The numeric value of the format-spec is too large", CSTR("{5000000000}"));
-  test_exception<Parser<CharT>>("The numeric value of the format-spec is too large", CSTR("{10000000000}"));
-
-  // *** Precision ***
-  test_exception<Parser<CharT>>("The format-spec should consume the input or end with a '}'", CSTR("."));
-  test_exception<Parser<CharT>>("The format-spec should consume the input or end with a '}'", CSTR(".1"));
-
-  // *** Locale-specific form ***
-  test_exception<Parser<CharT>>("The format-spec should consume the input or end with a '}'", CSTR("L"));
-
-  // *** Type ***
-  {
-    const char* unsuported_type = "The format-spec type has a type not supported for a pointer argument";
-    const char* not_a_type = "The format-spec should consume the input or end with a '}'";
-
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("A}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("B}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("C}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("D}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("E}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("F}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("G}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("H}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("I}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("J}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("K}"));
-    test_exception<Parser<CharT>>("The format-spec should consume the input or end with a '}'", CSTR("L"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("M}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("N}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("O}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("P}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("Q}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("R}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("S}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("T}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("U}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("V}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("W}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("X}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("Y}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("Z}"));
-
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("a}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("b}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("c}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("d}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("e}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("f}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("g}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("h}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("i}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("j}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("k}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("l}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("m}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("n}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("o}"));
-    test({.type = _Flags::_Type::__pointer}, 1, CSTR("p}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("q}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("r}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("s}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("t}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("u}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("v}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("w}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("x}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("y}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("z}"));
-  }
-
-  // **** General ***
-  test_exception<Parser<CharT>>("The format-spec should consume the input or end with a '}'", CSTR("ss"));
-}
-
-constexpr bool test() {
-  test<char>();
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  test<wchar_t>();
-#endif
-
-  return true;
-}
-
-int main(int, char**) {
-#if !defined(_WIN32) && !defined(_AIX)
-  // Make sure the parsers match the expectations. The layout of the
-  // subobjects is chosen to minimize the size required.
-  static_assert(sizeof(Parser<char>) == 2 * sizeof(uint32_t));
-#  ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  static_assert(sizeof(Parser<wchar_t>) == (sizeof(wchar_t) <= 2 ? 2 * sizeof(uint32_t) : 3 * sizeof(uint32_t)));
-#  endif
-#endif
-
-  test();
-  static_assert(test());
-
-  return 0;
-}

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_string.pass.cpp

-//===----------------------------------------------------------------------===//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-has-no-incomplete-format
-
-// <format>
-
-// Tests the parsing of the format string as specified in [format.string.std].
-// It validates whether the std-format-spec is valid for a string type.
-
-#include <format>
-#include <cassert>
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
-# include <iostream>
-#endif
-
-#include "test_macros.h"
-#include "make_string.h"
-#include "test_exception.h"
-
-#define CSTR(S) MAKE_CSTRING(CharT, S)
-
-using namespace std::__format_spec;
-
-template <class CharT>
-using Parser = __parser_string<CharT>;
-
-template <class CharT>
-struct Expected {
-  CharT fill = CharT(' ');
-  _Flags::_Alignment alignment = _Flags::_Alignment::__left;
-  uint32_t width = 0;
-  bool width_as_arg = false;
-  uint32_t precision = std::__format::__number_max;
-  bool precision_as_arg = true;
-  _Flags::_Type type = _Flags::_Type::__default;
-};
-
-template <class CharT>
-constexpr void test(Expected<CharT> expected, size_t size,
-                    std::basic_string_view<CharT> fmt) {
-  // Initialize parser with sufficient arguments to avoid the parsing to fail
-  // due to insufficient arguments.
-  std::basic_format_parse_context<CharT> parse_ctx(fmt,
-                                                   std::__format::__number_max);
-  auto begin = parse_ctx.begin();
-  auto end = parse_ctx.end();
-  Parser<CharT> parser;
-  auto it = parser.parse(parse_ctx);
-
-  assert(begin == parse_ctx.begin());
-  assert(end == parse_ctx.end());
-
-  assert(begin + size == it);
-  assert(parser.__fill == expected.fill);
-  assert(parser.__alignment == expected.alignment);
-  assert(parser.__sign == _Flags::_Sign::__default);
-  assert(parser.__alternate_form == false);
-  assert(parser.__zero_padding == false);
-  assert(parser.__width == expected.width);
-  assert(parser.__width_as_arg == expected.width_as_arg);
-  assert(parser.__precision == expected.precision);
-  assert(parser.__precision_as_arg == expected.precision_as_arg);
-  assert(parser.__locale_specific_form == false);
-  assert(parser.__type == expected.type);
-}
-
-template <class CharT>
-constexpr void test(Expected<CharT> expected, size_t size, const CharT* f) {
-  // The format-spec is valid if completely consumed or terminates at a '}'.
-  // The valid inputs all end with a '}'. The test is executed twice:
-  // - first with the terminating '}',
-  // - second consuming the entire input.
-  std::basic_string_view<CharT> fmt{f};
-  assert(fmt.back() == CharT('}') && "Pre-condition failure");
-
-  test(expected, size, fmt);
-  fmt.remove_suffix(1);
-  test(expected, size, fmt);
-}
-
-template <class CharT>
-constexpr void test() {
-  Parser<CharT> parser;
-
-  assert(parser.__fill == CharT(' '));
-  assert(parser.__alignment == _Flags::_Alignment::__left);
-  assert(parser.__sign == _Flags::_Sign::__default);
-  assert(parser.__alternate_form == false);
-  assert(parser.__zero_padding == false);
-  assert(parser.__width == 0);
-  assert(parser.__width_as_arg == false);
-  assert(parser.__precision == std::__format::__number_max);
-  assert(parser.__precision_as_arg == true);
-  assert(parser.__locale_specific_form == false);
-  assert(parser.__type == _Flags::_Type::__default);
-
-  test({}, 0, CSTR("}"));
-
-  // *** Align-fill ***
-  test({.alignment = _Flags::_Alignment::__left}, 1, CSTR("<}"));
-  test({.alignment = _Flags::_Alignment::__center}, 1, "^}");
-  test({.alignment = _Flags::_Alignment::__right}, 1, ">}");
-
-  test({.fill = CharT('L'), .alignment = _Flags::_Alignment::__left}, 2,
-       CSTR("L<}"));
-  test({.fill = CharT('#'), .alignment = _Flags::_Alignment::__center}, 2,
-       CSTR("#^}"));
-  test({.fill = CharT('0'), .alignment = _Flags::_Alignment::__right}, 2,
-       CSTR("0>}"));
-
-  test_exception<Parser<CharT>>(
-      "The format-spec fill field contains an invalid character", CSTR("{<"));
-  test_exception<Parser<CharT>>(
-      "The format-spec fill field contains an invalid character", CSTR("}<"));
-
-  // *** Sign ***
-  test_exception<Parser<CharT>>(
-      "The format-spec should consume the input or end with a '}'", CSTR("+"));
-  test_exception<Parser<CharT>>(
-      "The format-spec should consume the input or end with a '}'", CSTR("-"));
-  test_exception<Parser<CharT>>(
-      "The format-spec should consume the input or end with a '}'", CSTR(" "));
-
-  // *** Alternate form ***
-  test_exception<Parser<CharT>>(
-      "The format-spec should consume the input or end with a '}'", CSTR("#"));
-
-  // *** Zero padding ***
-  test_exception<Parser<CharT>>(
-      "A format-spec width field shouldn't have a leading zero", CSTR("0"));
-
-  // *** Width ***
-  test({.width = 0, .width_as_arg = false}, 0, CSTR("}"));
-  test({.width = 1, .width_as_arg = false}, 1, CSTR("1}"));
-  test({.width = 10, .width_as_arg = false}, 2, CSTR("10}"));
-  test({.width = 1000, .width_as_arg = false}, 4, CSTR("1000}"));
-  test({.width = 1000000, .width_as_arg = false}, 7, CSTR("1000000}"));
-
-  test({.width = 0, .width_as_arg = true}, 2, CSTR("{}}"));
-  test({.width = 0, .width_as_arg = true}, 3, CSTR("{0}}"));
-  test({.width = 1, .width_as_arg = true}, 3, CSTR("{1}}"));
-
-  test_exception<Parser<CharT>>(
-      "A format-spec width field shouldn't have a leading zero", CSTR("00"));
-
-  static_assert(std::__format::__number_max == 2'147'483'647,
-                "Update the assert and the test.");
-  test({.width = 2'147'483'647, .width_as_arg = false}, 10,
-       CSTR("2147483647}"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large", CSTR("2147483648"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large", CSTR("5000000000"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large", CSTR("10000000000"));
-
-  test_exception<Parser<CharT>>("End of input while parsing format-spec arg-id",
-                                CSTR("{"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{0"));
-  test_exception<Parser<CharT>>(
-      "The arg-id of the format-spec starts with an invalid character",
-      CSTR("{a"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{1"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{9"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{9:"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR("{9a"));
-
-  static_assert(std::__format::__number_max == 2'147'483'647,
-                "Update the assert and the test.");
-  // Note the static_assert tests whether the arg-id is valid.
-  // Therefore the following should be true arg-id < __format::__number_max.
-  test({.width = 2'147'483'646, .width_as_arg = true}, 12,
-       CSTR("{2147483646}}"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large",
-      CSTR("{2147483648}"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large",
-      CSTR("{5000000000}"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large",
-      CSTR("{10000000000}"));
-
-  // *** Precision ***
-  test({.precision = 0, .precision_as_arg = false}, 2, CSTR(".0}"));
-  test({.precision = 1, .precision_as_arg = false}, 2, CSTR(".1}"));
-  test({.precision = 10, .precision_as_arg = false}, 3, CSTR(".10}"));
-  test({.precision = 1000, .precision_as_arg = false}, 5, CSTR(".1000}"));
-  test({.precision = 1000000, .precision_as_arg = false}, 8, CSTR(".1000000}"));
-
-  test({.precision = 0, .precision_as_arg = true}, 3, CSTR(".{}}"));
-  test({.precision = 0, .precision_as_arg = true}, 4, CSTR(".{0}}"));
-  test({.precision = 1, .precision_as_arg = true}, 4, CSTR(".{1}}"));
-
-  test_exception<Parser<CharT>>(
-      "The format-spec precision field doesn't contain a value or arg-id",
-      CSTR(".a"));
-  test_exception<Parser<CharT>>(
-      "The format-spec precision field doesn't contain a value or arg-id",
-      CSTR(".:"));
-
-  static_assert(std::__format::__number_max == 2'147'483'647,
-                "Update the assert and the test.");
-  test({.precision = 2'147'483'647, .precision_as_arg = false}, 11,
-       CSTR(".2147483647}"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large", CSTR(".2147483648"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large", CSTR(".5000000000"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large",
-      CSTR(".10000000000"));
-
-  test_exception<Parser<CharT>>("End of input while parsing format-spec arg-id",
-                                CSTR(".{"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR(".{0"));
-  test_exception<Parser<CharT>>(
-      "The arg-id of the format-spec starts with an invalid character",
-      CSTR(".{a"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR(".{1"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR(".{9"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR(".{9:"));
-  test_exception<Parser<CharT>>("Invalid arg-id", CSTR(".{9a"));
-
-  static_assert(std::__format::__number_max == 2'147'483'647,
-                "Update the assert and the test.");
-  // Note the static_assert tests whether the arg-id is valid.
-  // Therefore the following should be true arg-id < __format::__number_max.
-  test({.precision = 2'147'483'646, .precision_as_arg = true}, 13,
-       CSTR(".{2147483646}}"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large",
-      CSTR(".{2147483648}"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large",
-      CSTR(".{5000000000}"));
-  test_exception<Parser<CharT>>(
-      "The numeric value of the format-spec is too large",
-      CSTR(".{10000000000}"));
-
-  // *** Width & Precision ***
-  test({.width = 1,
-        .width_as_arg = false,
-        .precision = 0,
-        .precision_as_arg = false},
-       3, CSTR("1.0}"));
-  test({.width = 0,
-        .width_as_arg = true,
-        .precision = 1,
-        .precision_as_arg = true},
-       5, CSTR("{}.{}}"));
-  test({.width = 10,
-        .width_as_arg = true,
-        .precision = 9,
-        .precision_as_arg = true},
-       8, CSTR("{10}.{9}}"));
-
-  // *** Locale-specific form ***
-  test_exception<Parser<CharT>>(
-      "The format-spec should consume the input or end with a '}'", CSTR("L"));
-
-  // *** Type ***
-
-  {
-    const char* unsuported_type =
-        "The format-spec type has a type not supported for a string argument";
-    const char* not_a_type =
-        "The format-spec should consume the input or end with a '}'";
-
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("A}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("B}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("C}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("D}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("E}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("F}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("G}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("H}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("I}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("J}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("K}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("L}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("M}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("N}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("O}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("P}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("Q}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("R}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("S}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("T}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("U}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("V}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("W}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("X}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("Y}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("Z}"));
-
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("a}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("b}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("c}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("d}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("e}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("f}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("g}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("h}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("i}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("j}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("k}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("l}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("m}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("n}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("o}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("p}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("q}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("r}"));
-    test({.type = _Flags::_Type::__string}, 1, CSTR("s}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("t}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("u}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("v}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("w}"));
-    test_exception<Parser<CharT>>(unsuported_type, CSTR("x}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("y}"));
-    test_exception<Parser<CharT>>(not_a_type, CSTR("z}"));
-  }
-  // **** General ***
-  test_exception<Parser<CharT>>(
-      "The format-spec should consume the input or end with a '}'", CSTR("ss"));
-}
-
-constexpr bool test() {
-  test<char>();
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  test<wchar_t>();
-#endif
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-  test<char8_t>();
-#endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
-  test<char16_t>();
-  test<char32_t>();
-#endif
-
-  return true;
-}
-
-int main(int, char**) {
-#ifndef _WIN32
-  // Make sure the parsers match the expectations. The layout of the
-  // subobjects is chosen to minimize the size required.
-  LIBCPP_STATIC_ASSERT(sizeof(Parser<char>) == 3 * sizeof(uint32_t));
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  LIBCPP_STATIC_ASSERT(
-      sizeof(Parser<wchar_t>) ==
-      (sizeof(wchar_t) <= 2 ? 3 * sizeof(uint32_t) : 4 * sizeof(uint32_t)));
-#endif
-#endif // _WIN32
-
-  test();
-  static_assert(test());
-
-  return 0;
-}

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_string_non_unicode.pass.cpp

 // This version runs the test when the platform doesn't have Unicode support.
 // REQUIRES: libcpp-has-no-unicode
 
 #include <format>
 #include <cassert>
 
 #include "test_macros.h"
 #include "make_string.h"
-
-#define CSTR(S) MAKE_CSTRING(CharT, S)
+#if 0
+#  define CSTR(S) MAKE_CSTRING(CharT, S)
 
 using namespace std::__format_spec;
 
 template <class CharT>
 constexpr bool operator==(const __string_alignment<CharT>& lhs,
                           const __string_alignment<CharT>& rhs) noexcept {
   return lhs.__last == rhs.__last && lhs.__size == rhs.__size &&
          lhs.__align == rhs.__align;

 
 template <class CharT>
 constexpr void test() {
   get_string_alignment<CharT>();
 }
 
 constexpr bool test() {
   test<char>();
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+#  ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
-#endif
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#  endif
+#  ifndef _LIBCPP_HAS_NO_CHAR8_T
   test<char8_t>();
-#endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
+#  endif
+#  ifndef TEST_HAS_NO_UNICODE_CHARS
   test<char16_t>();
   test<char32_t>();
-#endif
+#  endif
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }
+#endif

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_string_unicode.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "make_string.h"
 
 #define CSTR(S) MAKE_CSTRING(CharT, S)
 
 using namespace std::__format_spec;
-
+#if 0
 template <class CharT>
 constexpr bool operator==(const __string_alignment<CharT>& lhs,
                           const __string_alignment<CharT>& rhs) noexcept {
   return lhs.__last == rhs.__last && lhs.__size == rhs.__size &&
          lhs.__align == rhs.__align;
 }
 
 template <class CharT>
 constexpr void get_string_alignment(size_t offset, ptrdiff_t size, bool align,
                                     const CharT* str, size_t width,
                                     size_t precision) {
   std::basic_string_view<CharT> sv{str};
   __string_alignment<CharT> expected{sv.begin() + offset, size, align};
   __string_alignment<CharT> traits =
       __get_string_alignment(sv.begin(), sv.end(), width, precision);
   assert(traits == expected);
 }
-
+#endif
 template <class CharT>
 constexpr void estimate_column_width_fast(size_t expected, const CharT* str) {
   std::basic_string_view<CharT> sv{str};
   const CharT* out =
       __detail::__estimate_column_width_fast(sv.begin(), sv.end());
   assert(out == sv.begin() + expected);
 }
 
constexpr void estimate_column_width() {
   estimate_column_width(2, CSTR("\U0001f9ff")); // NAZAR AMULET
   estimate_column_width(
       2, CSTR("\U00020000")); // <CJK Ideograph Extension B, First>
   estimate_column_width(2, CSTR("\U0002fffd")); // Undefined Character
   estimate_column_width(
       2, CSTR("\U00030000")); // <CJK Ideograph Extension G, First>
   estimate_column_width(2, CSTR("\U0003fffd")); // Undefined Character
 }
-
+#if 0
 template <class CharT>
 constexpr void get_string_alignment() {
   // Truncate the input.
   get_string_alignment(2, 2, false, CSTR("abc"), 0, 2);
 
   // The 2-column character gets entirely rejected.
   get_string_alignment(1, 1, false, CSTR("a\u115f"), 0, 2);
 
if constexpr (sizeof(CharT) == 1) {
     if constexpr (std::same_as<CharT, char16_t>)
       get_string_alignment(2, 2, false, u"a\xdddd", 0, 3);
     else
       // Corrupt UTF-16 wchar_t seqence.
       get_string_alignment(2, 2, false, L"a\xdddd", 0, 3);
   }
   // UTF-32 doesn't combine characters, thus no corruption tests.
 }
+#endif
 
 template <class CharT>
 constexpr void test() {
   estimate_column_width_fast<CharT>();
   estimate_column_width<CharT>();
-  get_string_alignment<CharT>();
+  //  get_string_alignment<CharT>();
 }
 
 constexpr bool test() {
   test<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 #ifndef _LIBCPP_HAS_NO_CHAR8_T

libcxx/test/std/utilities/format/format.formatter/format.context/types.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// <format>
+
+// Class typedefs:
+// template<class Out, class charT>
+// class basic_format_context {
+// public:
+//   using iterator = Out
+//   using char_type = charT;
+//   template<class T> using formatter_type = formatter<T, charT>;
+// }
+//
+// Namespace std typedefs:
+// using format_context = basic_format_context<unspecified, char>;
+// using wformat_context = basic_format_context<unspecified, wchar_t>;
+
+#include <format>
+#include <string>
+#include <string_view>
+#include <type_traits>
+
+#include "test_macros.h"
+
+template <class OutIt, class CharT>
+constexpr void test() {
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<OutIt, CharT>::iterator,
+                     OutIt>);
+  static_assert(
+      std::is_same_v<
+          typename std::basic_format_context<OutIt, CharT>::char_type, CharT>);
+  static_assert(std::is_same_v<typename std::basic_format_context<
+                                   OutIt, CharT>::template formatter_type<bool>,
+                               std::formatter<bool, CharT>>);
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<
+                         OutIt, CharT>::template formatter_type<CharT>,
+                     std::formatter<CharT, CharT>>);
+  static_assert(std::is_same_v<typename std::basic_format_context<
+                                   OutIt, CharT>::template formatter_type<int>,
+                               std::formatter<int, CharT>>);
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<
+                         OutIt, CharT>::template formatter_type<unsigned>,
+                     std::formatter<unsigned, CharT>>);
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<
+                         OutIt, CharT>::template formatter_type<long long>,
+                     std::formatter<long long, CharT>>);
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<OutIt, CharT>::
+                         template formatter_type<unsigned long long>,
+                     std::formatter<unsigned long long, CharT>>);
+#ifndef TEST_HAS_NO_INT128
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<
+                         OutIt, CharT>::template formatter_type<__int128_t>,
+                     std::formatter<__int128_t, CharT>>);
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<
+                         OutIt, CharT>::template formatter_type<__uint128_t>,
+                     std::formatter<__uint128_t, CharT>>);
+#endif
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<
+                         OutIt, CharT>::template formatter_type<float>,
+                     std::formatter<float, CharT>>);
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<
+                         OutIt, CharT>::template formatter_type<double>,
+                     std::formatter<double, CharT>>);
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<
+                         OutIt, CharT>::template formatter_type<long double>,
+                     std::formatter<long double, CharT>>);
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<
+                         OutIt, CharT>::template formatter_type<const CharT*>,
+                     std::formatter<const CharT*, CharT>>);
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<OutIt, CharT>::
+                         template formatter_type<std::basic_string_view<CharT>>,
+                     std::formatter<std::basic_string_view<CharT>, CharT>>);
+  static_assert(
+      std::is_same_v<typename std::basic_format_context<
+                         OutIt, CharT>::template formatter_type<const void*>,
+                     std::formatter<const void*, CharT>>);
+}
+
+constexpr void test() {
+  test<std::back_insert_iterator<std::basic_string<char>>, char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<std::back_insert_iterator<std::basic_string<wchar_t>>, wchar_t>();
+#endif
+  test<std::back_insert_iterator<std::basic_string<char8_t>>, char8_t>();
+  test<std::back_insert_iterator<std::basic_string<char16_t>>, char16_t>();
+  test<std::back_insert_iterator<std::basic_string<char32_t>>, char32_t>();
+}
+
+template <class, class>
+constexpr bool is_basic_format_context_specialization = false;
+template <class It, class CharT>
+constexpr bool is_basic_format_context_specialization<std::basic_format_context<It, CharT>, CharT> = true;
+
+static_assert(is_basic_format_context_specialization<std::format_context, char>);
+LIBCPP_STATIC_ASSERT(
+    std::is_same_v<
+        std::format_context,
+        std::basic_format_context<
+            std::back_insert_iterator<std::__format::__output_buffer<char>>, char>>);
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+static_assert(is_basic_format_context_specialization<std::wformat_context, wchar_t>);
+LIBCPP_STATIC_ASSERT(
+    std::is_same_v<
+        std::wformat_context,
+        std::basic_format_context<
+            std::back_insert_iterator<std::__format::__output_buffer<wchar_t>>, wchar_t>>);
+#endif
+
+// Required for MSVC internal test runner compatibility.
+int main(int, char**) { return 0; }

libcxx/test/std/utilities/format/format.functions/format_tests.h

 void format_test_pointer(TestFunction check, ExceptionTest check_exception) {
   format_test_pointer<std::nullptr_t, CharT>(check, check_exception);
   format_test_pointer<void*, CharT>(check, check_exception);
   format_test_pointer<const void*, CharT>(check, check_exception);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void format_tests(TestFunction check, ExceptionTest check_exception) {
+
   // *** Test escaping  ***
 
   check.template operator()<"{{">(SV("{"));
   check.template operator()<"}}">(SV("}"));
 
   // *** Test argument ID ***
   check.template operator()<"hello {0:} {1:}">(SV("hello false true"), false, true);
   check.template operator()<"hello {1:} {0:}">(SV("hello true false"), false, true);