@swiftbrowser/wasm-sdk-cxx 0.0.0-stage → 0.9.0

package/wasm32-unknown-wasip1/WASI.sdk/include/c++/v1/__format/parser_std_format_spec.h

@@ -0,0 +1,1172 @@
+// -*- 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/copy_n.h>
+#include <__algorithm/min.h>
+#include <__assert>
+#include <__concepts/arithmetic.h>
+#include <__concepts/same_as.h>
+#include <__config>
+#include <__format/format_arg.h>
+#include <__format/format_error.h>
+#include <__format/format_parse_context.h>
+#include <__format/format_string.h>
+#include <__format/unicode.h>
+#include <__format/width_estimation_table.h>
+#include <__iterator/concepts.h>
+#include <__iterator/iterator_traits.h> // iter_value_t
+#include <__memory/addressof.h>
+#include <__type_traits/common_type.h>
+#include <__type_traits/is_constant_evaluated.h>
+#include <__type_traits/is_trivially_copyable.h>
+#include <__variant/monostate.h>
+#include <cstdint>
+#include <string>
+#include <string_view>
+
+#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 >= 20
+
+namespace __format_spec {
+
+[[noreturn]] _LIBCPP_HIDE_FROM_ABI inline void
+__throw_invalid_option_format_error(const char* __id, const char* __option) {
+  std::__throw_format_error(
+      (string("The format specifier for ") + __id + " does not allow the " + __option + " option").c_str());
+}
+
+[[noreturn]] _LIBCPP_HIDE_FROM_ABI inline void __throw_invalid_type_format_error(const char* __id) {
+  std::__throw_format_error(
+      (string("The type option contains an invalid value for ") + __id + " formatting argument").c_str());
+}
+
+template <contiguous_iterator _Iterator, class _ParseContext>
+_LIBCPP_HIDE_FROM_ABI constexpr __format::__parse_number_result<_Iterator>
+__parse_arg_id(_Iterator __begin, _Iterator __end, _ParseContext& __ctx) {
+  using _CharT = iter_value_t<_Iterator>;
+  // 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)
+    std::__throw_format_error("End of input while parsing an argument index");
+
+  __format::__parse_number_result __r = __format::__parse_arg_id(__begin, __end, __ctx);
+
+  if (__r.__last == __end || *__r.__last != _CharT('}'))
+    std::__throw_format_error("The argument index is invalid");
+
+  ++__r.__last;
+  return __r;
+}
+
+template <class _Context>
+_LIBCPP_HIDE_FROM_ABI constexpr uint32_t __substitute_arg_id(basic_format_arg<_Context> __format_arg) {
+  // [format.string.std]/8
+  //   If the corresponding formatting argument is not of integral type...
+  // This wording allows char and bool too. LWG-3720 changes the wording to
+  //    If the corresponding formatting argument is not of standard signed or
+  //    unsigned integer type,
+  // This means the 128-bit will not be valid anymore.
+  // TODO FMT Verify this resolution is accepted and add a test to verify
+  //          128-bit integrals fail and switch to visit_format_arg.
+  return std::__visit_format_arg(
+      [](auto __arg) -> uint32_t {
+        using _Type = decltype(__arg);
+        if constexpr (same_as<_Type, monostate>)
+          std::__throw_format_error("The argument index value is too large for the number of arguments supplied");
+
+        // [format.string.std]/8
+        // If { arg-idopt } is used in a width or precision, the value of the
+        // corresponding formatting argument is used in its place. If the
+        // corresponding formatting argument is not of standard signed or unsigned
+        // integer type, or its value is negative for precision or non-positive for
+        // width, an exception of type format_error is thrown.
+        //
+        // When an integral is used in a format function, it is stored as one of
+        // the types checked below. Other integral types are promoted. For example,
+        // a signed char is stored as an int.
+        if constexpr (same_as<_Type, int> || same_as<_Type, unsigned int> || //
+                      same_as<_Type, long long> || same_as<_Type, unsigned long long>) {
+          if constexpr (signed_integral<_Type>) {
+            if (__arg < 0)
+              std::__throw_format_error("An argument index may not 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))
+            std::__throw_format_error("The value of the argument index exceeds its maximum value");
+
+          return __arg;
+        } else
+          std::__throw_format_error("Replacement argument isn't a standard signed or unsigned integer type");
+      },
+      __format_arg);
+}
+
+/// 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.
+struct _LIBCPP_HIDE_FROM_ABI __fields {
+  uint16_t __sign_                 : 1 {false};
+  uint16_t __alternate_form_       : 1 {false};
+  uint16_t __zero_padding_         : 1 {false};
+  uint16_t __precision_            : 1 {false};
+  uint16_t __locale_specific_form_ : 1 {false};
+  uint16_t __type_                 : 1 {false};
+  // Determines the valid values for fill.
+  //
+  // Originally the fill could be any character except { and }. Range-based
+  // formatters use the colon to mark the beginning of the
+  // underlying-format-spec. To avoid parsing ambiguities these formatter
+  // specializations prohibit the use of the colon as a fill character.
+  uint16_t __use_range_fill_ : 1 {false};
+  uint16_t __clear_brackets_ : 1 {false};
+  uint16_t __consume_all_    : 1 {false};
+};
+
+// By not placing this constant in the formatter class it's not duplicated for
+// char and wchar_t.
+inline constexpr __fields __fields_bool{.__locale_specific_form_ = true, .__type_ = true, .__consume_all_ = true};
+inline constexpr __fields __fields_integral{
+    .__sign_                 = true,
+    .__alternate_form_       = true,
+    .__zero_padding_         = true,
+    .__locale_specific_form_ = true,
+    .__type_                 = true,
+    .__consume_all_          = true};
+inline constexpr __fields __fields_floating_point{
+    .__sign_                 = true,
+    .__alternate_form_       = true,
+    .__zero_padding_         = true,
+    .__precision_            = true,
+    .__locale_specific_form_ = true,
+    .__type_                 = true,
+    .__consume_all_          = true};
+inline constexpr __fields __fields_string{.__precision_ = true, .__type_ = true, .__consume_all_ = true};
+inline constexpr __fields __fields_pointer{.__zero_padding_ = true, .__type_ = true, .__consume_all_ = true};
+
+#  if _LIBCPP_STD_VER >= 23
+inline constexpr __fields __fields_tuple{.__use_range_fill_ = true, .__clear_brackets_ = true};
+inline constexpr __fields __fields_range{.__use_range_fill_ = true, .__clear_brackets_ = true};
+inline constexpr __fields __fields_fill_align_width{};
+#  endif
+
+enum class __alignment : uint8_t {
+  /// No alignment is set in the format string.
+  __default,
+  __left,
+  __center,
+  __right,
+  __zero_padding
+};
+
+enum class __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
+};
+
+enum class __type : uint8_t {
+  __default = 0,
+  __string,
+  __binary_lower_case,
+  __binary_upper_case,
+  __octal,
+  __decimal,
+  __hexadecimal_lower_case,
+  __hexadecimal_upper_case,
+  __pointer_lower_case,
+  __pointer_upper_case,
+  __char,
+  __hexfloat_lower_case,
+  __hexfloat_upper_case,
+  __scientific_lower_case,
+  __scientific_upper_case,
+  __fixed_lower_case,
+  __fixed_upper_case,
+  __general_lower_case,
+  __general_upper_case,
+  __debug
+};
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr uint32_t __create_type_mask(__type __t) {
+  uint32_t __shift = static_cast<uint32_t>(__t);
+  if (__shift == 0)
+    return 1;
+
+  if (__shift > 31)
+    std::__throw_format_error("The type does not fit in the mask");
+
+  return 1 << __shift;
+}
+
+inline constexpr uint32_t __type_mask_integer =
+    __create_type_mask(__type::__binary_lower_case) |      //
+    __create_type_mask(__type::__binary_upper_case) |      //
+    __create_type_mask(__type::__decimal) |                //
+    __create_type_mask(__type::__octal) |                  //
+    __create_type_mask(__type::__hexadecimal_lower_case) | //
+    __create_type_mask(__type::__hexadecimal_upper_case);
+
+struct __std {
+  __alignment __alignment_     : 3;
+  __sign __sign_               : 2;
+  bool __alternate_form_       : 1;
+  bool __locale_specific_form_ : 1;
+  __type __type_;
+};
+
+struct __chrono {
+  __alignment __alignment_     : 3;
+  bool __locale_specific_form_ : 1;
+  bool __hour_                 : 1;
+  bool __weekday_name_         : 1;
+  bool __weekday_              : 1;
+  bool __day_of_year_          : 1;
+  bool __week_of_year_         : 1;
+  bool __month_name_           : 1;
+};
+
+// The fill UCS scalar value.
+//
+// This is always an array, with 1, 2, or 4 elements.
+// The size of the data structure is always 32-bits.
+template <class _CharT>
+struct __code_point;
+
+template <>
+struct __code_point<char> {
+  char __data[4] = {' '};
+};
+
+#  if _LIBCPP_HAS_WIDE_CHARACTERS
+template <>
+struct __code_point<wchar_t> {
+  wchar_t __data[4 / sizeof(wchar_t)] = {L' '};
+};
+#  endif
+
+/// Contains the parsed formatting specifications.
+///
+/// This contains information for both the std-format-spec and the
+/// chrono-format-spec. This results in some unused members for both
+/// specifications. However these unused members don't increase the size
+/// of the structure.
+///
+/// This struct doesn't cross ABI boundaries so its layout doesn't need to be
+/// kept stable.
+template <class _CharT>
+struct __parsed_specifications {
+  union {
+    // The field __alignment_ is the first element in __std_ and __chrono_.
+    // This allows the code to always inspect this value regards which member
+    // of the union is the active member [class.union.general]/2.
+    //
+    // This is needed since the generic output routines handle the alignment of
+    // the output.
+    __alignment __alignment_ : 3;
+    __std __std_;
+    __chrono __chrono_;
+  };
+
+  /// The requested width.
+  ///
+  /// When the format-spec used an arg-id for this field it has already been
+  /// replaced with the value of that arg-id.
+  int32_t __width_;
+
+  /// The requested precision.
+  ///
+  /// When the format-spec used an arg-id for this field it has already been
+  /// replaced with the value of that arg-id.
+  int32_t __precision_;
+
+  __code_point<_CharT> __fill_;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __has_width() const { return __width_ > 0; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __has_precision() const { return __precision_ >= 0; }
+};
+
+// Validate the struct is small and cheap to copy since the struct is passed by
+// value in formatting functions.
+static_assert(sizeof(__parsed_specifications<char>) == 16);
+static_assert(is_trivially_copyable_v<__parsed_specifications<char>>);
+#  if _LIBCPP_HAS_WIDE_CHARACTERS
+static_assert(sizeof(__parsed_specifications<wchar_t>) == 16);
+static_assert(is_trivially_copyable_v<__parsed_specifications<wchar_t>>);
+#  endif
+
+/// The parser for the std-format-spec.
+///
+/// Note this class is a member of std::formatter specializations. It's
+/// expected developers will create their own formatter specializations that
+/// inherit from the std::formatter specializations. This means this class
+/// must be ABI stable. To aid the stability the unused bits in the class are
+/// set to zero. That way they can be repurposed if a future revision of the
+/// Standards adds new fields to std-format-spec.
+template <class _CharT>
+class __parser {
+public:
+  // Parses the format specification.
+  //
+  // Depending on whether the parsing is done compile-time or run-time
+  // the method slightly differs.
+  // - Only parses a field when it is in the __fields. Accepting all
+  //   fields and then validating the valid ones has a performance impact.
+  //   This is faster but gives slighly worse error messages.
+  // - At compile-time when a field is not accepted the parser will still
+  //   parse it and give an error when it's present. This gives a more
+  //   accurate error.
+  // The idea is that most times the format instead of the vformat
+  // functions are used. In that case the error will be detected during
+  // compilation and there is no need to pay for the run-time overhead.
+  template <class _ParseContext>
+  _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator __parse(_ParseContext& __ctx, __fields __fields) {
+    auto __begin = __ctx.begin();
+    auto __end   = __ctx.end();
+    if (__begin == __end || *__begin == _CharT('}') || (__fields.__use_range_fill_ && *__begin == _CharT(':')))
+      return __begin;
+
+    if (__parse_fill_align(__begin, __end) && __begin == __end)
+      return __begin;
+
+    if (__fields.__sign_) {
+      if (__parse_sign(__begin) && __begin == __end)
+        return __begin;
+    } else if (std::is_constant_evaluated() && __parse_sign(__begin)) {
+      std::__throw_format_error("The format specification does not allow the sign option");
+    }
+
+    if (__fields.__alternate_form_) {
+      if (__parse_alternate_form(__begin) && __begin == __end)
+        return __begin;
+    } else if (std::is_constant_evaluated() && __parse_alternate_form(__begin)) {
+      std::__throw_format_error("The format specifier does not allow the alternate form option");
+    }
+
+    if (__fields.__zero_padding_) {
+      if (__parse_zero_padding(__begin) && __begin == __end)
+        return __begin;
+    } else if (std::is_constant_evaluated() && __parse_zero_padding(__begin)) {
+      std::__throw_format_error("The format specifier does not allow the zero-padding option");
+    }
+
+    if (__parse_width(__begin, __end, __ctx) && __begin == __end)
+      return __begin;
+
+    if (__fields.__precision_) {
+      if (__parse_precision(__begin, __end, __ctx) && __begin == __end)
+        return __begin;
+    } else if (std::is_constant_evaluated() && __parse_precision(__begin, __end, __ctx)) {
+      std::__throw_format_error("The format specifier does not allow the precision option");
+    }
+
+    if (__fields.__locale_specific_form_) {
+      if (__parse_locale_specific_form(__begin) && __begin == __end)
+        return __begin;
+    } else if (std::is_constant_evaluated() && __parse_locale_specific_form(__begin)) {
+      std::__throw_format_error("The format specifier does not allow the locale-specific form option");
+    }
+
+    if (__fields.__clear_brackets_) {
+      if (__parse_clear_brackets(__begin) && __begin == __end)
+        return __begin;
+    } else if (std::is_constant_evaluated() && __parse_clear_brackets(__begin)) {
+      std::__throw_format_error("The format specifier does not allow the n option");
+    }
+
+    if (__fields.__type_)
+      __parse_type(__begin);
+
+    if (!__fields.__consume_all_)
+      return __begin;
+
+    if (__begin != __end && *__begin != _CharT('}'))
+      std::__throw_format_error("The format specifier should consume the input or end with a '}'");
+
+    return __begin;
+  }
+
+  // Validates the selected the parsed data.
+  //
+  // The valid fields in the parser may depend on the display type
+  // selected. But the type is the last optional field, so by the time
+  // it's known an option can't be used, it already has been parsed.
+  // This does the validation again.
+  //
+  // For example an integral may have a sign, zero-padding, or alternate
+  // form when the type option is not 'c'. So the generic approach is:
+  //
+  // typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_integral);
+  // if (__parser.__type_ == __format_spec::__type::__char) {
+  //   __parser.__validate((__format_spec::__fields_bool, "an integer");
+  //   ... // more char adjustments
+  // } else {
+  //   ... // validate an integral type.
+  // }
+  //
+  // For some types all valid options need a second validation run, like
+  // boolean types.
+  //
+  // Depending on whether the validation is done at compile-time or
+  // run-time the error differs
+  // - run-time the exception is thrown and contains the type of field
+  //   being validated.
+  // - at compile-time the line with `std::__throw_format_error` is shown
+  //   in the output. In that case it's important for the error to be on one
+  //   line.
+  // Note future versions of C++ may allow better compile-time error
+  // reporting.
+  _LIBCPP_HIDE_FROM_ABI constexpr void
+  __validate(__fields __fields, const char* __id, uint32_t __type_mask = -1) const {
+    if (!__fields.__sign_ && __sign_ != __sign::__default) {
+      if (std::is_constant_evaluated())
+        std::__throw_format_error("The format specifier does not allow the sign option");
+      else
+        __format_spec::__throw_invalid_option_format_error(__id, "sign");
+    }
+
+    if (!__fields.__alternate_form_ && __alternate_form_) {
+      if (std::is_constant_evaluated())
+        std::__throw_format_error("The format specifier does not allow the alternate form option");
+      else
+        __format_spec::__throw_invalid_option_format_error(__id, "alternate form");
+    }
+
+    if (!__fields.__zero_padding_ && __alignment_ == __alignment::__zero_padding) {
+      if (std::is_constant_evaluated())
+        std::__throw_format_error("The format specifier does not allow the zero-padding option");
+      else
+        __format_spec::__throw_invalid_option_format_error(__id, "zero-padding");
+    }
+
+    if (!__fields.__precision_ && __precision_ != -1) { // Works both when the precision has a value or an arg-id.
+      if (std::is_constant_evaluated())
+        std::__throw_format_error("The format specifier does not allow the precision option");
+      else
+        __format_spec::__throw_invalid_option_format_error(__id, "precision");
+    }
+
+    if (!__fields.__locale_specific_form_ && __locale_specific_form_) {
+      if (std::is_constant_evaluated())
+        std::__throw_format_error("The format specifier does not allow the locale-specific form option");
+      else
+        __format_spec::__throw_invalid_option_format_error(__id, "locale-specific form");
+    }
+
+    if ((__create_type_mask(__type_) & __type_mask) == 0) {
+      if (std::is_constant_evaluated())
+        std::__throw_format_error("The format specifier uses an invalid value for the type option");
+      else
+        __format_spec::__throw_invalid_type_format_error(__id);
+    }
+  }
+
+  /// \returns the `__parsed_specifications` with the resolved dynamic sizes..
+  _LIBCPP_HIDE_FROM_ABI __parsed_specifications<_CharT> __get_parsed_std_specifications(auto& __ctx) const {
+    return __parsed_specifications<_CharT>{
+        .__std_ = __std{.__alignment_            = __alignment_,
+                        .__sign_                 = __sign_,
+                        .__alternate_form_       = __alternate_form_,
+                        .__locale_specific_form_ = __locale_specific_form_,
+                        .__type_                 = __type_},
+        .__width_{__get_width(__ctx)},
+        .__precision_{__get_precision(__ctx)},
+        .__fill_{__fill_}};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI __parsed_specifications<_CharT> __get_parsed_chrono_specifications(auto& __ctx) const {
+    return __parsed_specifications<_CharT>{
+        .__chrono_ =
+            __chrono{.__alignment_            = __alignment_,
+                     .__locale_specific_form_ = __locale_specific_form_,
+                     .__hour_                 = __hour_,
+                     .__weekday_name_         = __weekday_name_,
+                     .__weekday_              = __weekday_,
+                     .__day_of_year_          = __day_of_year_,
+                     .__week_of_year_         = __week_of_year_,
+                     .__month_name_           = __month_name_},
+        .__width_{__get_width(__ctx)},
+        .__precision_{__get_precision(__ctx)},
+        .__fill_{__fill_}};
+  }
+
+  __alignment __alignment_     : 3 {__alignment::__default};
+  __sign __sign_               : 2 {__sign::__default};
+  bool __alternate_form_       : 1 {false};
+  bool __locale_specific_form_ : 1 {false};
+  bool __clear_brackets_       : 1 {false};
+  __type __type_{__type::__default};
+
+  // These flags are only used for formatting chrono. Since the struct has
+  // padding space left it's added to this structure.
+  bool __hour_ : 1 {false};
+
+  bool __weekday_name_ : 1 {false};
+  bool __weekday_      : 1 {false};
+
+  bool __day_of_year_  : 1 {false};
+  bool __week_of_year_ : 1 {false};
+
+  bool __month_name_ : 1 {false};
+
+  uint8_t __reserved_0_ : 2 {0};
+  uint8_t __reserved_1_ : 6 {0};
+  // These two flags are only used internally and not part of the
+  // __parsed_specifications. Therefore put them at the end.
+  bool __width_as_arg_     : 1 {false};
+  bool __precision_as_arg_ : 1 {false};
+
+  /// The requested width, either the value or the arg-id.
+  int32_t __width_{0};
+
+  /// The requested precision, either the value or the arg-id.
+  int32_t __precision_{-1};
+
+  __code_point<_CharT> __fill_{};
+
+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;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr void __validate_fill_character(_CharT __fill) {
+    // The forbidden fill characters all code points formed from a single code unit, thus the
+    // check can be omitted when more code units are used.
+    if (__fill == _CharT('{'))
+      std::__throw_format_error("The fill option contains an invalid value");
+  }
+
+#  if _LIBCPP_HAS_UNICODE
+  // range-fill and tuple-fill are identical
+  template <contiguous_iterator _Iterator>
+    requires same_as<_CharT, char>
+#    if _LIBCPP_HAS_WIDE_CHARACTERS
+          || (same_as<_CharT, wchar_t> && sizeof(wchar_t) == 2)
+#    endif
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_fill_align(_Iterator& __begin, _Iterator __end) {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __begin != __end,
+        "when called with an empty input the function will cause "
+        "undefined behavior by evaluating data not in the input");
+    __unicode::__code_point_view<_CharT> __view{__begin, __end};
+    __unicode::__consume_result __consumed = __view.__consume();
+    if (__consumed.__status != __unicode::__consume_result::__ok)
+      std::__throw_format_error("The format specifier contains malformed Unicode characters");
+
+    if (__view.__position() < __end && __parse_alignment(*__view.__position())) {
+      ptrdiff_t __code_units = __view.__position() - __begin;
+      if (__code_units == 1)
+        // The forbidden fill characters all are code points encoded
+        // in one code unit, thus the check can be omitted when more
+        // code units are used.
+        __validate_fill_character(*__begin);
+
+      std::copy_n(__begin, __code_units, std::addressof(__fill_.__data[0]));
+      __begin += __code_units + 1;
+      return true;
+    }
+
+    if (!__parse_alignment(*__begin))
+      return false;
+
+    ++__begin;
+    return true;
+  }
+
+#    if _LIBCPP_HAS_WIDE_CHARACTERS
+  template <contiguous_iterator _Iterator>
+    requires(same_as<_CharT, wchar_t> && sizeof(wchar_t) == 4)
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_fill_align(_Iterator& __begin, _Iterator __end) {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __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 && __parse_alignment(*(__begin + 1))) {
+      if (!__unicode::__is_scalar_value(*__begin))
+        std::__throw_format_error("The fill option contains an invalid value");
+
+      __validate_fill_character(*__begin);
+
+      __fill_.__data[0] = *__begin;
+      __begin += 2;
+      return true;
+    }
+
+    if (!__parse_alignment(*__begin))
+      return false;
+
+    ++__begin;
+    return true;
+  }
+
+#    endif // _LIBCPP_HAS_WIDE_CHARACTERS
+
+#  else // _LIBCPP_HAS_UNICODE
+  // range-fill and tuple-fill are identical
+  template <contiguous_iterator _Iterator>
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_fill_align(_Iterator& __begin, _Iterator __end) {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __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))) {
+        __validate_fill_character(*__begin);
+
+        __fill_.__data[0] = *__begin;
+        __begin += 2;
+        return true;
+      }
+    }
+
+    if (!__parse_alignment(*__begin))
+      return false;
+
+    ++__begin;
+    return true;
+  }
+
+#  endif // _LIBCPP_HAS_UNICODE
+
+  template <contiguous_iterator _Iterator>
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_sign(_Iterator& __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;
+  }
+
+  template <contiguous_iterator _Iterator>
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_alternate_form(_Iterator& __begin) {
+    if (*__begin != _CharT('#'))
+      return false;
+
+    __alternate_form_ = true;
+    ++__begin;
+    return true;
+  }
+
+  template <contiguous_iterator _Iterator>
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_zero_padding(_Iterator& __begin) {
+    if (*__begin != _CharT('0'))
+      return false;
+
+    if (__alignment_ == __alignment::__default)
+      __alignment_ = __alignment::__zero_padding;
+    ++__begin;
+    return true;
+  }
+
+  template <contiguous_iterator _Iterator>
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_width(_Iterator& __begin, _Iterator __end, auto& __ctx) {
+    if (*__begin == _CharT('0'))
+      std::__throw_format_error("The width option should not have a leading zero");
+
+    if (*__begin == _CharT('{')) {
+      __format::__parse_number_result __r = __format_spec::__parse_arg_id(++__begin, __end, __ctx);
+      __width_as_arg_                     = true;
+      __width_                            = __r.__value;
+      __begin                             = __r.__last;
+      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_INTERNAL(__width_ != 0,
+                            "A zero value isn't allowed and should be impossible, "
+                            "due to validations in this function");
+    __begin = __r.__last;
+    return true;
+  }
+
+  template <contiguous_iterator _Iterator>
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_precision(_Iterator& __begin, _Iterator __end, auto& __ctx) {
+    if (*__begin != _CharT('.'))
+      return false;
+
+    ++__begin;
+    if (__begin == __end)
+      std::__throw_format_error("End of input while parsing format specifier precision");
+
+    if (*__begin == _CharT('{')) {
+      __format::__parse_number_result __arg_id = __format_spec::__parse_arg_id(++__begin, __end, __ctx);
+      __precision_as_arg_                      = true;
+      __precision_                             = __arg_id.__value;
+      __begin                                  = __arg_id.__last;
+      return true;
+    }
+
+    if (*__begin < _CharT('0') || *__begin > _CharT('9'))
+      std::__throw_format_error("The precision option does not contain a value or an argument index");
+
+    __format::__parse_number_result __r = __format::__parse_number(__begin, __end);
+    __precision_                        = __r.__value;
+    __precision_as_arg_                 = false;
+    __begin                             = __r.__last;
+    return true;
+  }
+
+  template <contiguous_iterator _Iterator>
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_locale_specific_form(_Iterator& __begin) {
+    if (*__begin != _CharT('L'))
+      return false;
+
+    __locale_specific_form_ = true;
+    ++__begin;
+    return true;
+  }
+
+  template <contiguous_iterator _Iterator>
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_clear_brackets(_Iterator& __begin) {
+    if (*__begin != _CharT('n'))
+      return false;
+
+    __clear_brackets_ = true;
+    ++__begin;
+    return true;
+  }
+
+  template <contiguous_iterator _Iterator>
+  _LIBCPP_HIDE_FROM_ABI constexpr void __parse_type(_Iterator& __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':
+      __type_ = __type::__hexfloat_upper_case;
+      break;
+    case 'B':
+      __type_ = __type::__binary_upper_case;
+      break;
+    case 'E':
+      __type_ = __type::__scientific_upper_case;
+      break;
+    case 'F':
+      __type_ = __type::__fixed_upper_case;
+      break;
+    case 'G':
+      __type_ = __type::__general_upper_case;
+      break;
+    case 'X':
+      __type_ = __type::__hexadecimal_upper_case;
+      break;
+    case 'a':
+      __type_ = __type::__hexfloat_lower_case;
+      break;
+    case 'b':
+      __type_ = __type::__binary_lower_case;
+      break;
+    case 'c':
+      __type_ = __type::__char;
+      break;
+    case 'd':
+      __type_ = __type::__decimal;
+      break;
+    case 'e':
+      __type_ = __type::__scientific_lower_case;
+      break;
+    case 'f':
+      __type_ = __type::__fixed_lower_case;
+      break;
+    case 'g':
+      __type_ = __type::__general_lower_case;
+      break;
+    case 'o':
+      __type_ = __type::__octal;
+      break;
+    case 'p':
+      __type_ = __type::__pointer_lower_case;
+      break;
+    case 'P':
+      __type_ = __type::__pointer_upper_case;
+      break;
+    case 's':
+      __type_ = __type::__string;
+      break;
+    case 'x':
+      __type_ = __type::__hexadecimal_lower_case;
+      break;
+#  if _LIBCPP_STD_VER >= 23
+    case '?':
+      __type_ = __type::__debug;
+      break;
+#  endif
+    default:
+      return;
+    }
+    ++__begin;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI int32_t __get_width(auto& __ctx) const {
+    if (!__width_as_arg_)
+      return __width_;
+
+    return __format_spec::__substitute_arg_id(__ctx.arg(__width_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI int32_t __get_precision(auto& __ctx) const {
+    if (!__precision_as_arg_)
+      return __precision_;
+
+    return __format_spec::__substitute_arg_id(__ctx.arg(__precision_));
+  }
+};
+
+// Validates whether the reserved bitfields don't change the size.
+static_assert(sizeof(__parser<char>) == 16);
+#  if _LIBCPP_HAS_WIDE_CHARACTERS
+static_assert(sizeof(__parser<wchar_t>) == 16);
+#  endif
+
+_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:
+  case __format_spec::__type::__debug:
+    break;
+
+  default:
+    std::__throw_format_error("The type option contains an invalid value for a string formatting argument");
+  }
+}
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_bool_string(__parser<_CharT>& __parser, const char* __id) {
+  __parser.__validate(__format_spec::__fields_bool, __id);
+  if (__parser.__alignment_ == __alignment::__default)
+    __parser.__alignment_ = __alignment::__left;
+}
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_char(__parser<_CharT>& __parser, const char* __id) {
+  __format_spec::__process_display_type_bool_string(__parser, __id);
+}
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_bool(__parser<_CharT>& __parser, const char* __id) {
+  switch (__parser.__type_) {
+  case __format_spec::__type::__default:
+  case __format_spec::__type::__string:
+    __format_spec::__process_display_type_bool_string(__parser, __id);
+    break;
+
+  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:
+    break;
+
+  default:
+    __format_spec::__throw_invalid_type_format_error(__id);
+  }
+}
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_char(__parser<_CharT>& __parser, const char* __id) {
+  switch (__parser.__type_) {
+  case __format_spec::__type::__default:
+  case __format_spec::__type::__char:
+  case __format_spec::__type::__debug:
+    __format_spec::__process_display_type_char(__parser, __id);
+    break;
+
+  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:
+    break;
+
+  default:
+    __format_spec::__throw_invalid_type_format_error(__id);
+  }
+}
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_integer(__parser<_CharT>& __parser, const char* __id) {
+  switch (__parser.__type_) {
+  case __format_spec::__type::__default:
+  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:
+    break;
+
+  case __format_spec::__type::__char:
+    __format_spec::__process_display_type_char(__parser, __id);
+    break;
+
+  default:
+    __format_spec::__throw_invalid_type_format_error(__id);
+  }
+}
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_floating_point(__parser<_CharT>& __parser, const char* __id) {
+  switch (__parser.__type_) {
+  case __format_spec::__type::__default:
+  case __format_spec::__type::__hexfloat_lower_case:
+  case __format_spec::__type::__hexfloat_upper_case:
+    // Precision specific behavior will be handled later.
+    break;
+  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.__precision_ == -1)
+      // Set the default precision for the call to to_chars.
+      __parser.__precision_ = 6;
+    break;
+
+  default:
+    __format_spec::__throw_invalid_type_format_error(__id);
+  }
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_pointer(__format_spec::__type __type, const char* __id) {
+  switch (__type) {
+  case __format_spec::__type::__default:
+  case __format_spec::__type::__pointer_lower_case:
+  case __format_spec::__type::__pointer_upper_case:
+    break;
+
+  default:
+    __format_spec::__throw_invalid_type_format_error(__id);
+  }
+}
+
+template <contiguous_iterator _Iterator>
+struct __column_width_result {
+  /// The number of output columns.
+  size_t __width_;
+  /// One beyond the last code unit used in the estimation.
+  ///
+  /// This limits the original output to fit in the wanted number of columns.
+  _Iterator __last_;
+};
+
+template <contiguous_iterator _Iterator>
+__column_width_result(size_t, _Iterator) -> __column_width_result<_Iterator>;
+
+/// Since a column width can be two it's possible that the requested column
+/// width can't be achieved. Depending on the intended usage the policy can be
+/// selected.
+/// - When used as precision the maximum width may not be exceeded and the
+///   result should be "rounded down" to the previous boundary.
+/// - When used as a width we're done once the minimum is reached, but
+///   exceeding is not an issue. Rounding down is an issue since that will
+///   result in writing fill characters. Therefore the result needs to be
+///   "rounded up".
+enum class __column_width_rounding { __down, __up };
+
+#  if _LIBCPP_HAS_UNICODE
+
+namespace __detail {
+template <contiguous_iterator _Iterator>
+_LIBCPP_HIDE_FROM_ABI constexpr __column_width_result<_Iterator> __estimate_column_width_grapheme_clustering(
+    _Iterator __first, _Iterator __last, size_t __maximum, __column_width_rounding __rounding) noexcept {
+  using _CharT = iter_value_t<_Iterator>;
+  __unicode::__extended_grapheme_cluster_view<_CharT> __view{__first, __last};
+
+  __column_width_result<_Iterator> __result{0, __first};
+  while (__result.__last_ != __last && __result.__width_ <= __maximum) {
+    typename __unicode::__extended_grapheme_cluster_view<_CharT>::__cluster __cluster = __view.__consume();
+    int __width = __width_estimation_table::__estimated_width(__cluster.__code_point_);
+
+    // When the next entry would exceed the maximum width the previous width
+    // might be returned. For example when a width of 100 is requested the
+    // returned width might be 99, since the next code point has an estimated
+    // column width of 2. This depends on the rounding flag.
+    // When the maximum is exceeded the loop will abort the next iteration.
+    if (__rounding == __column_width_rounding::__down && __result.__width_ + __width > __maximum)
+      return __result;
+
+    __result.__width_ += __width;
+    __result.__last_ = __cluster.__last_;
+  }
+
+  return __result;
+}
+
+} // namespace __detail
+
+// Unicode can be stored in several formats: UTF-8, UTF-16, and UTF-32.
+// Depending on format the relation between the number of code units stored and
+// the number of output columns differs. The first relation is the number of
+// code units forming a code point. (The text assumes the code units are
+// unsigned.)
+// - UTF-8 The number of code units is between one and four. The first 127
+//   Unicode code points match the ASCII character set. When the highest bit is
+//   set it means the code point has more than one code unit.
+// - UTF-16: The number of code units is between 1 and 2. When the first
+//   code unit is in the range [0xd800,0xdfff) it means the code point uses two
+//   code units.
+// - UTF-32: The number of code units is always one.
+//
+// The code point to the number of columns is specified in
+// [format.string.std]/11. This list might change in the future.
+//
+// Another thing to be taken into account is Grapheme clustering. This means
+// that in some cases multiple code points are combined one element in the
+// output. For example:
+// - an ASCII character with a combined diacritical mark
+// - an emoji with a skin tone modifier
+// - a group of combined people emoji to create a family
+// - a combination of flag emoji
+//
+// See also:
+// - [format.string.general]/11
+// - https://en.wikipedia.org/wiki/UTF-8#Encoding
+// - https://en.wikipedia.org/wiki/UTF-16#U+D800_to_U+DFFF
+
+_LIBCPP_HIDE_FROM_ABI constexpr bool __is_ascii(char32_t __c) { return __c < 0x80; }
+
+/// Determines the number of output columns needed to render the input.
+///
+/// \note When the scanner encounters malformed Unicode it acts as-if every
+/// code unit is a one column code point. Typically a terminal uses the same
+/// strategy and replaces every malformed code unit with a one column
+/// replacement character.
+///
+/// \param __first    Points to the first element of the input range.
+/// \param __last     Points beyond the last element of the input range.
+/// \param __maximum  The maximum number of output columns. The returned number
+///                   of estimated output columns will not exceed this value.
+/// \param __rounding Selects the rounding method.
+///                   \c __down result.__width_ <= __maximum
+///                   \c __up result.__width_ <= __maximum + 1
+template <class _CharT, class _Iterator = typename basic_string_view<_CharT>::const_iterator>
+_LIBCPP_HIDE_FROM_ABI constexpr __column_width_result<_Iterator> __estimate_column_width(
+    basic_string_view<_CharT> __str, size_t __maximum, __column_width_rounding __rounding) noexcept {
+  // The width estimation is done in two steps:
+  // - Quickly process for the ASCII part. ASCII has the following properties
+  //   - One code unit is one code point
+  //   - Every code point has an estimated width of one
+  // - When needed it will a Unicode Grapheme clustering algorithm to find
+  //   the proper place for truncation.
+
+  if (__str.empty() || __maximum == 0)
+    return {0, __str.begin()};
+
+  // ASCII has one caveat; when an ASCII character is followed by a non-ASCII
+  // character they might be part of an extended grapheme cluster. For example:
+  //   an ASCII letter and a COMBINING ACUTE ACCENT
+  // The truncate should happen after the COMBINING ACUTE ACCENT. Therefore we
+  // need to scan one code unit beyond the requested precision. When this code
+  // unit is non-ASCII we omit the current code unit and let the Grapheme
+  // clustering algorithm do its work.
+  auto __it = __str.begin();
+  if (__format_spec::__is_ascii(*__it)) {
+    do {
+      --__maximum;
+      ++__it;
+      if (__it == __str.end())
+        return {__str.size(), __str.end()};
+
+      if (__maximum == 0) {
+        if (__format_spec::__is_ascii(*__it))
+          return {static_cast<size_t>(__it - __str.begin()), __it};
+
+        break;
+      }
+    } while (__format_spec::__is_ascii(*__it));
+    --__it;
+    ++__maximum;
+  }
+
+  ptrdiff_t __ascii_size = __it - __str.begin();
+  __column_width_result __result =
+      __detail::__estimate_column_width_grapheme_clustering(__it, __str.end(), __maximum, __rounding);
+
+  __result.__width_ += __ascii_size;
+  return __result;
+}
+#  else // _LIBCPP_HAS_UNICODE
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI constexpr __column_width_result<typename basic_string_view<_CharT>::const_iterator>
+__estimate_column_width(basic_string_view<_CharT> __str, size_t __maximum, __column_width_rounding) noexcept {
+  // When Unicode isn't supported assume ASCII and every code unit is one code
+  // point. In ASCII the estimated column width is always one. Thus there's no
+  // need for rounding.
+  size_t __width = std::min(__str.size(), __maximum);
+  return {__width, __str.begin() + __width};
+}
+
+#  endif // _LIBCPP_HAS_UNICODE
+
+} // namespace __format_spec
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___FORMAT_PARSER_STD_FORMAT_SPEC_H