[libc++][format] Implements formatting pointer.

[Mordante]

Summary

The feature is applied as DR instead of a normal paper. MSVC STL and
libstdc++ will do the same.

Implements

• P2510R3 Formatting pointers

Depends on D153192

[Mordante]

CI fixes.

[Mordante]

Rebased on dependency.

[Mordante]

CI fixes.

[ldionne]

libcxx/docs/Status/Cxx2cPapers.csv

9

Can you add a note that P2510R3 is applied as a DR?

10

Here and below, let's use 17.0. See also D154461.

libcxx/utils/generate_feature_test_macro_components.py

465

[Mordante]

libcxx/docs/Status/Cxx2cPapers.csv

9

Good point, I've mentioned MSVC STL and libstdc++ will do the same, to make clear this is portable.

10

Thanks for the cleanup patch!

libcxx/docs/ReleaseNotes.rst

 ------------------
 - P2520R0 - ``move_iterator<T*>`` should be a random access iterator
 - P1328R1 - ``constexpr type_info::operator==()``
 - P1413R3 - Formatting ``thread::id`` (the ``stacktrace`` is not done yet)
 - P2675R1 - ``format``'s width estimation is too approximate and not forward compatible
 - P2505R5 - Monadic operations for ``std::expected``
 - P2711R1 - Making Multi-Param Constructors Of views explicit (``join_with_view`` is not done yet)
 - P2572R1 - ``std::format`` fill character allowances
+- P2510R3 - Formatting pointers
 
 Improvements and New Features
 -----------------------------
 - ``std::equal`` and ``std::ranges::equal`` are now forwarding to ``std::memcmp`` for integral types and pointers,
   which can lead up to 40x performance improvements.
 
 - ``std::string_view`` now provides iterators that check for out-of-bounds accesses when the safe
   libc++ mode is enabled.

libcxx/docs/Status/Cxx2c.rst

 Paper Status
 ====================================
 
 .. csv-table::
    :file: Cxx2cPapers.csv
    :header-rows: 1
    :widths: auto
 
+.. note::
+
+   .. [#note-P2510R3] This paper is applied as DR against C++20. (MSVC STL and libstdc++ will do the same.)
+
 .. _issues-status-cxx2c:
 
 Library Working Group Issues Status
 ====================================
 
 .. csv-table::
    :file: Cxx2cIssues.csv
    :header-rows: 1
    :widths: auto

libcxx/docs/Status/Cxx2cPapers.csv

 "Paper #","Group","Paper Name","Meeting","Status","First released version","Labels"
 "`P2497R0 <https://wg21.link/P2497R0>`__","LWG","Testing for success or failure of ``<charconv>`` functions","Varna June 2023","","",""
 "`P2592R3 <https://wg21.link/P2592R3>`__","LWG","Hashing support for ``std::chrono`` value classes","Varna June 2023","","",""
 "`P2587R3 <https://wg21.link/P2587R3>`__","LWG","``to_string`` or not ``to_string``","Varna June 2023","","","|format|"
 "`P2562R1 <https://wg21.link/P2562R1>`__","LWG","``constexpr`` Stable Sorting","Varna June 2023","","",""
 "`P2545R4 <https://wg21.link/P2545R4>`__","LWG","Read-Copy Update (RCU)","Varna June 2023","","",""
 "`P2530R3 <https://wg21.link/P2530R3>`__","LWG","Hazard Pointers for C++26","Varna June 2023","","",""
 "`P2538R1 <https://wg21.link/P2538R1>`__","LWG","ADL-proof ``std::projected``","Varna June 2023","","","|ranges|"
 "`P2495R3 <https://wg21.link/P2495R3>`__","LWG","Interfacing ``stringstreams`` with ``string_view``","Varna June 2023","","",""
-"`P2510R3 <https://wg21.link/P2510R3>`__","LWG","Formatting pointers","Varna June 2023","|In Progress|","","|format|"
+"`P2510R3 <https://wg21.link/P2510R3>`__","LWG","Formatting pointers","Varna June 2023","|Complete| [#note-P2510R3]_","17.0","|format|"
 "`P2198R7 <https://wg21.link/P2198R7>`__","LWG","Freestanding Feature-Test Macros and Implementation-Defined Extensions","Varna June 2023","","",""
 "`P2338R4 <https://wg21.link/P2338R4>`__","LWG","Freestanding Library: Character primitives and the C library","Varna June 2023","","",""
 "`P2013R5 <https://wg21.link/P2013R5>`__","LWG","Freestanding Language: Optional ``::operator new``","Varna June 2023","","",""
 "`P2363R5 <https://wg21.link/P2363R5>`__","LWG","Extending associative containers with the remaining heterogeneous overloads","Varna June 2023","","",""
 "`P1901R2 <https://wg21.link/P1901R2>`__","LWG","Enabling the Use of ``weak_ptr`` as Keys in Unordered Associative Containers","Varna June 2023","","",""
 "`P1885R12 <https://wg21.link/P1885R12>`__","LWG","Naming Text Encodings to Demystify Them","Varna June 2023","","",""
 "`P0792R14 <https://wg21.link/P0792R14>`__","LWG","``function_ref``: a type-erased callable reference","Varna June 2023","","",""
 "`P2874R2 <https://wg21.link/P2874R2>`__","LWG","Mandating Annex D Require No More","Varna June 2023","","",""

libcxx/docs/Status/FormatIssues.csv

 Number,Name,Standard,Assignee,Status,First released version
 `P0645 <https://wg21.link/P0645>`_,"Text Formatting","C++20",Mark de Wever,|Complete|,14.0
 `P1652 <https://wg21.link/P1652>`_,"Printf corner cases in std::format","C++20",Mark de Wever,|Complete|,14.0
 `P1892 <https://wg21.link/P1892>`_,"Extended locale-specific presentation specifiers for std::format","C++20",Mark de Wever,|Complete|,14.0
 `P1868 <https://wg21.link/P1868>`_,"width: clarifying units of width and precision in std::format (Implements the unicode support.)","C++20",Mark de Wever,|Complete|,14.0
 `P2216 <https://wg21.link/P2216>`_,"std::format improvements","C++20",Mark de Wever,|Complete|,15.0
 `P2418 <https://wg21.link/P2418>`__,"Add support for ``std::generator``-like types to ``std::format``","C++20",Mark de Wever,|Complete|,15.0
 "`P2093R14 <https://wg21.link/P2093R14>`__","Formatted output","C++23",Mark de Wever,|In Progress|,
 "`P2286R8 <https://wg21.link/P2286R8>`__","Formatting Ranges","C++23","Mark de Wever","|Complete|",16.0
 "`P2508R1 <https://wg21.link/P2508R1>`__","Exposing ``std::basic-format-string``","C++23","Mark de Wever","|Complete|",15.0
 "`P2585R0 <https://wg21.link/P2585R0>`__","Improving default container formatting","C++23","Mark de Wever","|Complete|",17.0
 "`P2539R4 <https://wg21.link/P2539R4>`__","Should the output of ``std::print`` to a terminal be synchronized with the underlying stream?","C++23","Mark de Wever"
 "`P2713R1 <https://wg21.link/P2713R1>`__","Escaping improvements in ``std::format``","C++23","Mark de Wever",""
 "`P2675R1 <https://wg21.link/P2675R1>`__","``format``'s width estimation is too approximate and not forward compatible","C++23","Mark de Wever","|Complete|",17.0
 "`P2572R1 <https://wg21.link/P2572R1>`__","``std::format`` fill character allowances","C++23","Mark de Wever","|Complete|",17.0
 "`P2693R1 <https://wg21.link/P2693R1>`__","Formatting ``thread::id`` and ``stacktrace``","C++23","Mark de Wever","|In progress|"
-"`P2510R3 <https://wg21.link/P2510R3>`__","Formatting pointers","C++26","Mark de Wever","|In Progress|",
+"`P2510R3 <https://wg21.link/P2510R3>`__","Formatting pointers","C++26","Mark de Wever","|Complete|", 17.0
 "`P2757R3 <https://wg21.link/P2757R3>`__","Type-checking format args","C++26","","",
 "`P2637R3 <https://wg21.link/P2637R3>`__","Member ``visit``","C++26","","",
 `P1361 <https://wg21.link/P1361>`_,"Integration of chrono with text formatting","C++20",Mark de Wever,|In Progress|,
 `P2372 <https://wg21.link/P2372>`__,"Fixing locale handling in chrono formatters","C++20",Mark de Wever,|In Progress|,
 "`P2419R2 <https://wg21.link/P2419R2>`__","Clarify handling of encodings in localized formatting of chrono types","C++23",

libcxx/docs/UsingLibcxx.rst

 available in C++20 as an extension.
 
 For padding Unicode strings the ``format`` library relies on the Unicode
 Standard. Libc++ retroactively updates the Unicode Standard in older C++
 versions. This allows the library to have better estimates for newly introduced
 Unicode code points, without requiring the user to use the latest C++ version
 in their code base.
 
+In C++26 formatting pointers gained a type ``P`` and allows to use
+zero-padding. These options have been retroactively applied to C++20.
+
 Turning off ASan annotation in containers
 -----------------------------------------
 
 ``__asan_annotate_container_with_allocator`` is a customization point to allow users to disable
 `Address Sanitizer annotations for containers <https://github.com/google/sanitizers/wiki/AddressSanitizerContainerOverflow>`_ for specific allocators. This may be necessary for allocators that access allocated memory.
 This customization point exists only when ``_LIBCPP_HAS_ASAN_CONTAINER_ANNOTATIONS_FOR_ALL_ALLOCATORS`` Feature Test Macro is defined.
 
 For allocators not running destructors, it is also possible to `bulk-unpoison memory <https://github.com/google/sanitizers/wiki/AddressSanitizerManualPoisoning>`_ instead of disabling annotations altogether.

libcxx/include/__format/formatter_pointer.h

_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
     __format_spec::__process_display_type_pointer(__parser_.__type_);
     return __result;
   }
 
   template <class _FormatContext>
   _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(const void* __ptr, _FormatContext& __ctx) const {
     __format_spec::__parsed_specifications<_CharT> __specs = __parser_.__get_parsed_std_specifications(__ctx);
     __specs.__std_.__alternate_form_                       = true;
-    __specs.__std_.__type_                                 = __format_spec::__type::__hexadecimal_lower_case;
+    __specs.__std_.__type_ =
+        __specs.__std_.__type_ == __format_spec::__type::__pointer_upper_case
+            ? __format_spec::__type::__hexadecimal_upper_case
+            : __format_spec::__type::__hexadecimal_lower_case;
+
     return __formatter::__format_integer(reinterpret_cast<uintptr_t>(__ptr), __ctx, __specs);
   }
 
-  __format_spec::__parser<_CharT> __parser_{.__alignment_ = __format_spec::__alignment::__right};
+  __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 <__fmt_char_type _CharT>

libcxx/include/__format/parser_std_format_spec.h

 inline constexpr __fields __fields_floating_point{
     .__sign_                 = true,
     .__alternate_form_       = true,
     .__zero_padding_         = true,
     .__precision_            = true,
     .__locale_specific_form_ = true,
     .__type_                 = true};
 inline constexpr __fields __fields_string{.__precision_ = true, .__type_ = true};
-inline constexpr __fields __fields_pointer{.__type_ = true};
+inline constexpr __fields __fields_pointer{.__zero_padding_ = true, .__type_ = true};
 
 #  if _LIBCPP_STD_VER >= 23
 inline constexpr __fields __fields_tuple{.__use_range_fill_ = true};
 inline constexpr __fields __fields_range{.__use_range_fill_ = true};
 inline constexpr __fields __fields_fill_align_width{};
 #  endif
 
 enum class _LIBCPP_ENUM_VIS __alignment : uint8_t {
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,
+  __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,
case 'f':
       break;
     case 'g':
       __type_ = __type::__general_lower_case;
       break;
     case 'o':
       __type_ = __type::__octal;
       break;
     case 'p':
-      __type_ = __type::__pointer;
+      __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
_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_floating_point(__parser<_CharT>& __parser) {
   default:
     std::__throw_format_error("The format-spec type has a type not supported for a floating-point argument");
   }
 }
 
 _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:
+  case __format_spec::__type::__pointer_lower_case:
+  case __format_spec::__type::__pointer_upper_case:
     break;
 
   default:
     std::__throw_format_error("The format-spec type has a type not supported for a pointer argument");
   }
 }
 
 template <contiguous_iterator _Iterator>

libcxx/test/std/containers/container.adaptors/container.adaptors.format/format.functions.tests.h

void test_pointer(TestFunction check, ExceptionTest check_exception, auto&& input) {
 
   // *** sign ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
 
   // *** alternate form ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check(SV("[0x0000]"), SV("{::06}"), input);
+  check(SV("[0x0000]"), SV("{::06p}"), input);
+  check(SV("[0X0000]"), SV("{::06P}"), input);
 
   // *** precision ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
-  for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("p"))
+  for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("pP"))
     check_exception("The format-spec type has a type not supported for a pointer argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^[::0x0]^^^"), SV("{:^^12::>5}"), input);
   check(SV("^^[::0x0]^^^"), SV("{:^^{}::>5}"), input, 12);
   check(SV("^^[::0x0]^^^"), SV("{:^^{}::>{}}"), input, 12, 5);
 
   check(SV("^^[::0x0]^^^"), SV("{:^^12::>5}"), input);

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

std::vector<std::basic_string_view<CharT>> invalid_types(std::string_view valid) {
   std::vector<std::basic_string_view<CharT>> result;
 
 #define CASE(T)                                                                                                        \
 case #T[0]:                                                                                                            \
   result.push_back(SV("Invalid formatter type {:" #T "}"));                                                            \
   break;
 
 #if TEST_STD_VER > 20
-  constexpr std::string_view types = "aAbBcdeEfFgGopsxX?";
+  constexpr std::string_view types = "aAbBcdeEfFgGopPsxX?";
 #else
-  constexpr std::string_view types = "aAbBcdeEfFgGopsxX";
+  constexpr std::string_view types = "aAbBcdeEfFgGopPsxX";
 #endif
 
   for (auto type : types) {
     if (valid.find(type) != std::string::npos)
       continue;
 
     switch (type) {
       CASE(a)
       CASE(A)
       CASE(b)
       CASE(B)
       CASE(c)
       CASE(d)
       CASE(e)
       CASE(E)
       CASE(f)
       CASE(F)
       CASE(g)
       CASE(G)
       CASE(o)
       CASE(p)
+      CASE(P)
       CASE(s)
       CASE(x)
       CASE(X)
       CASE(?)
     case 0:
       break;
     default:
       assert(false && "Add the type to the list of cases.");
void format_test_pointer(TestFunction check, ExceptionTest check_exception) {
   check(SV("answer is '0x0   '"), SV("answer is '{:<6}'"), P(nullptr));
   check(SV("answer is ' 0x0  '"), SV("answer is '{:^6}'"), P(nullptr));
 
   // The fill character ':' is allowed here (P0645) but not in ranges (P2286).
   check(SV("answer is ':::0x0'"), SV("answer is '{::>6}'"), P(nullptr));
   check(SV("answer is '0x0:::'"), SV("answer is '{::<6}'"), P(nullptr));
   check(SV("answer is ':0x0::'"), SV("answer is '{::^6}'"), P(nullptr));
 
+  // Test whether zero padding is ignored
+  check(SV("answer is ':::0x0'"), SV("answer is '{::>06}'"), P(nullptr));
+  check(SV("answer is '0x0:::'"), SV("answer is '{::<06}'"), P(nullptr));
+  check(SV("answer is ':0x0::'"), SV("answer is '{::^06}'"), P(nullptr));
+
   // *** Sign ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{:-}"), P(nullptr));
   check_exception("The format-spec should consume the input or end with a '}'", SV("{:+}"), P(nullptr));
   check_exception("The format-spec should consume the input or end with a '}'", SV("{: }"), P(nullptr));
 
   // *** alternate form ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{:#}"), P(nullptr));
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{:0}"), P(nullptr));
+  check(SV("answer is '0x0000'"), SV("answer is '{:06}'"), P(nullptr));
+  check(SV("answer is '0x0000'"), SV("answer is '{:06p}'"), P(nullptr));
+  check(SV("answer is '0X0000'"), SV("answer is '{:06P}'"), P(nullptr));
 
   // *** precision ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{:.}"), P(nullptr));
 
   // *** locale-specific form ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), P(nullptr));
 
   // *** type ***
-  for (const auto& fmt : invalid_types<CharT>("p"))
+  for (const auto& fmt : invalid_types<CharT>("pP"))
     check_exception("The format-spec type has a type not supported for a pointer argument", fmt, P(nullptr));
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void format_test_handle(TestFunction check, ExceptionTest check_exception) {
   // *** Valid permuatations ***
   check(SV("answer is '0xaaaa'"), SV("answer is '{}'"), status::foo);
   check(SV("answer is '0xaaaa'"), SV("answer is '{:x}'"), status::foo);

libcxx/test/std/utilities/format/format.range/format.range.fmtset/format.functions.tests.h

void test_pointer(TestFunction check, ExceptionTest check_exception, auto&& input) {
 
   // *** sign ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
 
   // *** alternate form ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check(SV("{0x0000}"), SV("{::06}"), input);
+  check(SV("{0x0000}"), SV("{::06p}"), input);
+  check(SV("{0X0000}"), SV("{::06P}"), input);
 
   // *** precision ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
-  for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("p"))
+  for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("pP"))
     check_exception("The format-spec type has a type not supported for a pointer argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^{::0x0}^^^"), SV("{:^^12::>5}"), input);
   check(SV("^^{::0x0}^^^"), SV("{:^^{}::>5}"), input, 12);
   check(SV("^^{::0x0}^^^"), SV("{:^^{}::>{}}"), input, 12, 5);
 
   check(SV("^^{::0x0}^^^"), SV("{:^^12::>5}"), input);

libcxx/test/std/utilities/format/format.range/format.range.formatter/format.functions.tests.h

void test_pointer(TestFunction check, ExceptionTest check_exception, auto&& input) {
 
   // *** sign ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{::-}"), input);
 
   // *** alternate form ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{::#}"), input);
 
   // *** zero-padding ***
-  check_exception("A format-spec width field shouldn't have a leading zero", SV("{::05}"), input);
+  check(SV("[0x0000]"), SV("{::06}"), input);
+  check(SV("[0x0000]"), SV("{::06p}"), input);
+  check(SV("[0X0000]"), SV("{::06P}"), input);
 
   // *** precision ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{::.}"), input);
 
   // *** locale-specific form ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{::L}"), input);
 
   // *** type ***
-  for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("p"))
+  for (std::basic_string_view<CharT> fmt : fmt_invalid_nested_types<CharT>("pP"))
     check_exception("The format-spec type has a type not supported for a pointer argument", fmt, input);
 
   // ***** Both have a format-spec
   check(SV("^^[::0x0]^^^"), SV("{:^^12::>5}"), input);
   check(SV("^^[::0x0]^^^"), SV("{:^^{}::>5}"), input, 12);
   check(SV("^^[::0x0]^^^"), SV("{:^^{}::>{}}"), input, 12, 5);
 
   check(SV("^^[::0x0]^^^"), SV("{:^^12::>5}"), input);

libcxx/test/std/utilities/format/format.tuple/format.functions.tests.h

void test_tuple_or_pair_int_int(TestFunction check, ExceptionTest check_exception, TupleOrPair&& input) {
 
   // *** locale-specific form ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** type ***
   check(SV("__42: 99___"), SV("{:_^11m}"), input);
   check(SV("__42, 99___"), SV("{:_^11n}"), input);
 
-  for (CharT c : SV("aAbBcdeEfFgGopsxX?")) {
+  for (CharT c : SV("aAbBcdeEfFgGopPsxX?")) {
     check_exception("The format-spec should consume the input or end with a '}'",
                     std::basic_string_view{STR("{:") + c + STR("}")},
                     input);
   }
 }
 
 template <class CharT, class TestFunction, class ExceptionTest, class TupleOrPair>
 void test_tuple_or_pair_int_string(TestFunction check, ExceptionTest check_exception, TupleOrPair&& input) {
void test_tuple_or_pair_int_string(TestFunction check, ExceptionTest check_exception, TupleOrPair&& input) {
 
   // *** locale-specific form ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** type ***
   check(SV("__42: \"hello\"___"), SV("{:_^16m}"), input);
   check(SV("__42, \"hello\"___"), SV("{:_^16n}"), input);
 
-  for (CharT c : SV("aAbBcdeEfFgGopsxX?")) {
+  for (CharT c : SV("aAbBcdeEfFgGopPsxX?")) {
     check_exception("The format-spec should consume the input or end with a '}'",
                     std::basic_string_view{STR("{:") + c + STR("}")},
                     input);
   }
 }
 
 template <class CharT, class TestFunction, class TupleOrPair>
 void test_escaping(TestFunction check, TupleOrPair&& input) {
void test_tuple_int(TestFunction check, ExceptionTest check_exception) {
 
   // *** locale-specific form ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** type ***
   check_exception("The format specifier m requires a pair or a two-element tuple", SV("{:m}"), input);
   check(SV("__42___"), SV("{:_^7n}"), input);
 
-  for (CharT c : SV("aAbBcdeEfFgGopsxX?")) {
+  for (CharT c : SV("aAbBcdeEfFgGopPsxX?")) {
     check_exception("The format-spec should consume the input or end with a '}'",
                     std::basic_string_view{STR("{:") + c + STR("}")},
                     input);
   }
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_tuple_int_string_color(TestFunction check, ExceptionTest check_exception) {
void test_tuple_int_string_color(TestFunction check, ExceptionTest check_exception) {
 
   // *** locale-specific form ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** type ***
   check_exception("The format specifier m requires a pair or a two-element tuple", SV("{:m}"), input);
   check(SV("__42, \"hello\", \"red\"___"), SV("{:_^23n}"), input);
 
-  for (CharT c : SV("aAbBcdeEfFgGopsxX?")) {
+  for (CharT c : SV("aAbBcdeEfFgGopPsxX?")) {
     check_exception("The format-spec should consume the input or end with a '}'",
                     std::basic_string_view{STR("{:") + c + STR("}")},
                     input);
   }
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_tuple_int_int(TestFunction check, ExceptionTest check_exception) {
void test_nested(TestFunction check, ExceptionTest check_exception, Nested&& input) {
 
   // *** locale-specific form ***
   check_exception("The format-spec should consume the input or end with a '}'", SV("{:L}"), input);
 
   // *** type ***
   check(SV("__42: (\"hello\", \"red\")___"), SV("{:_^25m}"), input);
   check(SV("__42, (\"hello\", \"red\")___"), SV("{:_^25n}"), input);
 
-  for (CharT c : SV("aAbBcdeEfFgGopsxX?")) {
+  for (CharT c : SV("aAbBcdeEfFgGopPsxX?")) {
     check_exception("The format-spec should consume the input or end with a '}'",
                     std::basic_string_view{STR("{:") + c + STR("}")},
                     input);
   }
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void run_tests(TestFunction check, ExceptionTest check_exception) {

libcxx/test/support/format.functions.common.h

 namespace detail {
 template <class CharT, std::size_t N>
 std::basic_string<CharT> get_colons() {
   static std::basic_string<CharT> result(N, CharT(':'));
   return result;
 }
 
 constexpr std::string_view get_format_types() {
-  return "aAbBcdeEfFgGopsxX"
+  return "aAbBcdeEfFgGopPsxX"
 #if TEST_STD_VER > 20
          "?"
 #endif
       ;
 }
 
 template <class CharT, /*format_types types,*/ size_t N>
 std::vector<std::basic_string<CharT>> fmt_invalid_types(std::string_view valid) {

libcxx/utils/generate_feature_test_macro_components.py

for x in [
             "values": {
                 # "c++20": 201907 Not implemented P1361R2 Integration of chrono with text formatting
                 # "c++20": 202106 Fully implemented
                 # "c++20": 202110 Not implemented P2372R3 Fixing locale handling in chrono formatters
                 "c++20": 202106,
                 # "c++23": 202207, Not implemented P2419R2 Clarify handling of encodings in localized formatting of chrono types
             },
             # Note these three papers are adopted at the June 2023 meeting and have sequential numbering
-            # 202304 P2510R3 Formatting pointers
+            # 202304 P2510R3 Formatting pointers (Implemented)
             # 202305 P2757R3 Type-checking format args
             # 202306 P2637R3 Member Visit
             "headers": ["format"],
             "unimplemented": True,
         },
         {
             "name": "__cpp_lib_format_ranges",
             "values": {"c++23": 202207},