[libcxx-commits] [libcxx] 787ccd3 - [libc++][format] Adds formatter pointer.
Mark de Wever via libcxx-commits
libcxx-commits at lists.llvm.org
Mon Jan 24 09:13:07 PST 2022
Author: Mark de Wever
Date: 2022-01-24T18:13:02+01:00
New Revision: 787ccd345cbb3a569ba751580bb806552b4b6e57
URL: https://github.com/llvm/llvm-project/commit/787ccd345cbb3a569ba751580bb806552b4b6e57
DIFF: https://github.com/llvm/llvm-project/commit/787ccd345cbb3a569ba751580bb806552b4b6e57.diff
LOG: [libc++][format] Adds formatter pointer.
This implements the last required formatter specialization.
Completes:
- LWG 3251 Are std::format alignment specifiers applied to string arguments?
- LWG 3340 Formatting functions should throw on argument/format string mismatch in §[format.functions]
- LWG 3540 §[format.arg] There should be no const in basic_format_arg(const T* p)
Implements parts of:
- P0645 Text Formatting
Depends on D114001
Reviewed By: ldionne, vitaut, #libc
Differential Revision: https://reviews.llvm.org/D115988
Added:
libcxx/include/__format/formatter_pointer.h
libcxx/test/libcxx/diagnostics/detail.headers/format/formatter_pointer.module.verify.cpp
libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_pointer.pass.cpp
libcxx/test/std/utilities/format/format.formatter/format.context/format.formatter.spec/formatter.pointer.pass.cpp
Modified:
libcxx/docs/Status/Cxx20Issues.csv
libcxx/docs/Status/Cxx2bIssues.csv
libcxx/include/CMakeLists.txt
libcxx/include/__format/format_arg.h
libcxx/include/__format/parser_std_format_spec.h
libcxx/include/format
libcxx/include/module.modulemap
libcxx/test/libcxx/utilities/format/format.arguments/format.arg/visit_format_arg.pass.cpp
libcxx/test/std/utilities/format/format.functions/format_tests.h
Removed:
################################################################################
diff --git a/libcxx/docs/Status/Cxx20Issues.csv b/libcxx/docs/Status/Cxx20Issues.csv
index 034fac3ca22f8..daa6466f87515 100644
--- a/libcxx/docs/Status/Cxx20Issues.csv
+++ b/libcxx/docs/Status/Cxx20Issues.csv
@@ -207,7 +207,7 @@
"`3247 <https://wg21.link/LWG3247>`__","``ranges::iter_move``\ should perform ADL-only lookup of ``iter_move``\ ","Prague","","","|ranges|"
"`3248 <https://wg21.link/LWG3248>`__","``std::format``\ ``#b``\ , ``#B``\ , ``#o``\ , ``#x``\ , and ``#X``\ presentation types misformat negative numbers","Prague","|Complete|","14.0","|format|"
"`3250 <https://wg21.link/LWG3250>`__","``std::format``\ : ``#``\ (alternate form) for NaN and inf","Prague","|Complete|","14.0","|format|"
-"`3251 <https://wg21.link/LWG3251>`__","Are ``std::format``\ alignment specifiers applied to string arguments?","Prague","","","|format|"
+"`3251 <https://wg21.link/LWG3251>`__","Are ``std::format``\ alignment specifiers applied to string arguments?","Prague","|Complete|","14.0","|format|"
"`3252 <https://wg21.link/LWG3252>`__","Parse locale's aware modifiers for commands are not consistent with POSIX spec","Prague","","","|chrono|"
"`3254 <https://wg21.link/LWG3254>`__","Strike ``stop_token``\ 's ``operator!=``\ ","Prague","",""
"`3255 <https://wg21.link/LWG3255>`__","``span``\ 's ``array``\ constructor is too strict","Prague","|Complete|",""
@@ -256,7 +256,7 @@
"`3334 <https://wg21.link/LWG3334>`__","``basic_osyncstream``\ move assignment and destruction calls ``basic_syncbuf::emit()``\ twice","Prague","",""
"`3335 <https://wg21.link/LWG3335>`__","Resolve C++20 NB comments US 273 and GB 274","Prague","","","|ranges|"
"`3338 <https://wg21.link/LWG3338>`__","Rename ``default_constructible``\ to ``default_initializable``\ ","Prague","|Complete|","13.0"
-"`3340 <https://wg21.link/LWG3340>`__","Formatting functions should throw on argument/format string mismatch in |sect|\ [format.functions]","Prague","","","|format|"
+"`3340 <https://wg21.link/LWG3340>`__","Formatting functions should throw on argument/format string mismatch in |sect|\ [format.functions]","Prague","|Complete|","14.0","|format|"
"`3346 <https://wg21.link/LWG3346>`__","``pair``\ and ``tuple``\ copy and move constructor have backwards specification","Prague","",""
"`3347 <https://wg21.link/LWG3347>`__","``std::pair<T, U>``\ now requires ``T``\ and ``U``\ to be less-than-comparable","Prague","",""
"`3348 <https://wg21.link/LWG3348>`__","``__cpp_lib_unwrap_ref``\ in wrong header","Prague","|Complete|","12.0"
diff --git a/libcxx/docs/Status/Cxx2bIssues.csv b/libcxx/docs/Status/Cxx2bIssues.csv
index 27bc1e5832967..cbc12d27a5614 100644
--- a/libcxx/docs/Status/Cxx2bIssues.csv
+++ b/libcxx/docs/Status/Cxx2bIssues.csv
@@ -84,7 +84,7 @@
`3533 <https://wg21.link/LWG3533>`__,"Make ``base() const &`` consistent across iterator wrappers that supports ``input_iterators``","June 2021","","","|ranges|"
`3536 <https://wg21.link/LWG3536>`__,"Should ``chrono::from_stream()`` assign zero to duration for failure?","June 2021","","","|chrono|"
`3539 <https://wg21.link/LWG3539>`__,"``format_to`` must not copy models of ``output_iterator<const charT&>``","June 2021","","","|format|"
-`3540 <https://wg21.link/LWG3540>`__,"§[format.arg] There should be no const in ``basic_format_arg(const T* p)``","June 2021","","","|format|"
+`3540 <https://wg21.link/LWG3540>`__,"§[format.arg] There should be no const in ``basic_format_arg(const T* p)``","June 2021","|Complete|","14.0","|format|"
`3541 <https://wg21.link/LWG3541>`__,"``indirectly_readable_traits`` should be SFINAE-friendly for all types","June 2021","|Complete|","14.0","|ranges|"
`3542 <https://wg21.link/LWG3542>`__,"``basic_format_arg`` mishandles ``basic_string_view`` with custom traits","June 2021","|Complete|","14.0","|format|"
`3543 <https://wg21.link/LWG3543>`__,"Definition of when ``counted_iterators`` refer to the same sequence isn't quite right","June 2021","","","|ranges|"
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index 3886ddba8e4e5..278e848e6ecbf 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -181,6 +181,7 @@ set(files
__format/formatter_floating_point.h
__format/formatter_integer.h
__format/formatter_integral.h
+ __format/formatter_pointer.h
__format/formatter_string.h
__format/parser_std_format_spec.h
__functional/binary_function.h
diff --git a/libcxx/include/__format/format_arg.h b/libcxx/include/__format/format_arg.h
index 59429c13d4154..2153287a8a61c 100644
--- a/libcxx/include/__format/format_arg.h
+++ b/libcxx/include/__format/format_arg.h
@@ -245,7 +245,9 @@ class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT basic_format_arg {
explicit basic_format_arg(nullptr_t) noexcept
: __ptr(nullptr), __type_(__format::__arg_t::__ptr) {}
- // TODO FMT Implement the _Tp* constructor.
+ template <class _Tp>
+ requires is_void_v<_Tp> _LIBCPP_HIDE_FROM_ABI explicit basic_format_arg(_Tp* __p) noexcept
+ : __ptr(__p), __type_(__format::__arg_t::__ptr) {}
};
#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
diff --git a/libcxx/include/__format/formatter_pointer.h b/libcxx/include/__format/formatter_pointer.h
new file mode 100644
index 0000000000000..aa2eb641c6c6d
--- /dev/null
+++ b/libcxx/include/__format/formatter_pointer.h
@@ -0,0 +1,91 @@
+// -*- 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 <__availability>
+#include <__config>
+#include <__debug>
+#include <__format/format_error.h>
+#include <__format/format_fwd.h>
+#include <__format/formatter.h>
+#include <__format/formatter_integral.h>
+#include <__format/parser_std_format_spec.h>
+#include <__iterator/access.h>
+#include <__nullptr>
+#include <cstdint>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17
+
+// TODO FMT Remove this once we require compilers with proper C++20 support.
+// If the compiler has no concepts support, the format header will be disabled.
+// Without concepts support enable_if needs to be used and that too much effort
+// to support compilers with partial C++20 support.
+# if !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+namespace __format_spec {
+
+template <__formatter::__char_type _CharT>
+class _LIBCPP_TEMPLATE_VIS __formatter_pointer : public __parser_pointer<_CharT> {
+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));
+
+ // 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());
+
+ return __formatter::__write(__ctx.out(), __buffer, __last, __size, this->__width, this->__fill, this->__alignment);
+ }
+};
+
+} // namespace __format_spec
+
+// [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> {};
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<void*, _CharT>
+ : public __format_spec::__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> {};
+
+# endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+#endif //_LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FORMAT_FORMATTER_POINTER_H
diff --git a/libcxx/include/__format/parser_std_format_spec.h b/libcxx/include/__format/parser_std_format_spec.h
index 75fc626c84ac1..9d893e9ced27f 100644
--- a/libcxx/include/__format/parser_std_format_spec.h
+++ b/libcxx/include/__format/parser_std_format_spec.h
@@ -826,7 +826,108 @@ class _LIBCPP_TEMPLATE_VIS __parser_floating_point
}
};
-// TODO FMT Add a parser for pointer values.
+/**
+ * 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>
diff --git a/libcxx/include/format b/libcxx/include/format
index 3a186469dd5c0..53de4a0e6ca06 100644
--- a/libcxx/include/format
+++ b/libcxx/include/format
@@ -279,6 +279,7 @@ namespace std {
#include <__format/formatter_char.h>
#include <__format/formatter_floating_point.h>
#include <__format/formatter_integer.h>
+#include <__format/formatter_pointer.h>
#include <__format/formatter_string.h>
#include <__format/parser_std_format_spec.h>
#include <__variant/monostate.h>
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
index c940a6d11d816..90fae9bb8362d 100644
--- a/libcxx/include/module.modulemap
+++ b/libcxx/include/module.modulemap
@@ -506,6 +506,7 @@ module std [system] {
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_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" }
}
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/format/formatter_pointer.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/format/formatter_pointer.module.verify.cpp
new file mode 100644
index 0000000000000..abb82de85f37a
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/format/formatter_pointer.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// 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: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__format/formatter_pointer.h'}}
+#include <__format/formatter_pointer.h>
diff --git a/libcxx/test/libcxx/utilities/format/format.arguments/format.arg/visit_format_arg.pass.cpp b/libcxx/test/libcxx/utilities/format/format.arguments/format.arg/visit_format_arg.pass.cpp
index b6e34d78c8ac8..76548c97d77ba 100644
--- a/libcxx/test/libcxx/utilities/format/format.arguments/format.arg/visit_format_arg.pass.cpp
+++ b/libcxx/test/libcxx/utilities/format/format.arguments/format.arg/visit_format_arg.pass.cpp
@@ -346,6 +346,10 @@ void test() {
// Test pointer types.
test<Context, const void*>(nullptr);
+ int i = 0;
+ test<Context, const void*>(static_cast<void*>(&i));
+ const int ci = 0;
+ test<Context, const void*>(static_cast<const void*>(&ci));
}
void test() {
diff --git a/libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_pointer.pass.cpp b/libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_pointer.pass.cpp
new file mode 100644
index 0000000000000..7a34bbeb8e25a
--- /dev/null
+++ b/libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_pointer.pass.cpp
@@ -0,0 +1,254 @@
+//===----------------------------------------------------------------------===//
+// 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-no-concepts
+// 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;
+}
diff --git a/libcxx/test/std/utilities/format/format.formatter/format.context/format.formatter.spec/formatter.pointer.pass.cpp b/libcxx/test/std/utilities/format/format.formatter/format.context/format.formatter.spec/formatter.pointer.pass.cpp
new file mode 100644
index 0000000000000..b60943becdefe
--- /dev/null
+++ b/libcxx/test/std/utilities/format/format.formatter/format.context/format.formatter.spec/formatter.pointer.pass.cpp
@@ -0,0 +1,107 @@
+//===----------------------------------------------------------------------===//
+// 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-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// <format>
+
+// [format.formatter.spec]:
+// Each header that declares the template `formatter` provides the following
+// enabled specializations:
+// ...
+// For each charT, the pointer type specializations
+// - template<> struct formatter<nullptr_t, charT>;
+// - template<> struct formatter<void*, charT>;
+// - template<> struct formatter<const void*, charT>;
+
+#include <format>
+
+#include <array>
+#include <cassert>
+#include <cmath>
+#include <charconv>
+#include <concepts>
+#include <string>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "make_string.h"
+
+#define STR(S) MAKE_STRING(CharT, S)
+
+template <class StringT, class StringViewT, class PointerT>
+void test(StringT expected, StringViewT fmt, PointerT arg) {
+ using CharT = typename StringT::value_type;
+ auto parse_ctx = std::basic_format_parse_context<CharT>(fmt);
+ std::formatter<PointerT, CharT> formatter;
+ static_assert(std::semiregular<decltype(formatter)>);
+
+ auto it = formatter.parse(parse_ctx);
+ assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
+
+ StringT result;
+ auto out = std::back_inserter(result);
+ using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
+
+ auto format_ctx = std::__format_context_create<decltype(out), CharT>(out, std::make_format_args<FormatCtxT>(arg));
+ formatter.format(arg, format_ctx);
+
+ if (expected.empty()) {
+ std::array<char, 128> buffer;
+ buffer[0] = CharT('0');
+ buffer[1] = CharT('x');
+ expected.append(buffer.begin(),
+ std::to_chars(buffer.begin() + 2, buffer.end(), reinterpret_cast<uintptr_t>(arg), 16).ptr);
+ }
+ assert(result == expected);
+}
+
+template <class StringT, class PointerT>
+void test_termination_condition(StringT expected, StringT f, PointerT arg) {
+ // 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.
+ using CharT = typename StringT::value_type;
+ std::basic_string_view<CharT> fmt{f};
+ assert(fmt.back() == CharT('}') && "Pre-condition failure");
+
+ test(expected, fmt, arg);
+ fmt.remove_suffix(1);
+ test(expected, fmt, arg);
+}
+
+template <class CharT>
+void test_nullptr_t() {
+ test_termination_condition(STR("0x0"), STR("}"), nullptr);
+}
+
+template <class PointerT, class CharT>
+void test_pointer_type() {
+ test_termination_condition(STR("0x0"), STR("}"), PointerT(0));
+ test_termination_condition(STR("0x42"), STR("}"), PointerT(0x42));
+ test_termination_condition(STR("0xffff"), STR("}"), PointerT(0xffff));
+ test_termination_condition(STR(""), STR("}"), PointerT(-1));
+}
+
+template <class CharT>
+void test_all_pointer_types() {
+ test_nullptr_t<CharT>();
+ test_pointer_type<void*, CharT>();
+ test_pointer_type<const void*, CharT>();
+}
+
+int main(int, char**) {
+ test_all_pointer_types<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+ test_all_pointer_types<wchar_t>();
+#endif
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/format/format.functions/format_tests.h b/libcxx/test/std/utilities/format/format.functions/format_tests.h
index c2eeb236f99d0..4b269bbd4e64c 100644
--- a/libcxx/test/std/utilities/format/format.functions/format_tests.h
+++ b/libcxx/test/std/utilities/format/format.functions/format_tests.h
@@ -2484,6 +2484,47 @@ void format_test_floating_point(TestFunction check, ExceptionTest check_exceptio
format_test_floating_point<long double, CharT>(check, check_exception);
}
+template <class P, class CharT, class TestFunction, class ExceptionTest>
+void format_test_pointer(TestFunction check, ExceptionTest check_exception) {
+ // *** align-fill & width ***
+ check(STR("answer is ' 0x0'"), STR("answer is '{:6}'"), P(nullptr));
+ check(STR("answer is ' 0x0'"), STR("answer is '{:>6}'"), P(nullptr));
+ check(STR("answer is '0x0 '"), STR("answer is '{:<6}'"), P(nullptr));
+ check(STR("answer is ' 0x0 '"), STR("answer is '{:^6}'"), P(nullptr));
+
+ check(STR("answer is '---0x0'"), STR("answer is '{:->6}'"), P(nullptr));
+ check(STR("answer is '0x0---'"), STR("answer is '{:-<6}'"), P(nullptr));
+ check(STR("answer is '-0x0--'"), STR("answer is '{:-^6}'"), P(nullptr));
+
+ // *** Sign ***
+ check_exception("The format-spec should consume the input or end with a '}'", STR("{:-}"), P(nullptr));
+ check_exception("The format-spec should consume the input or end with a '}'", STR("{:+}"), P(nullptr));
+ check_exception("The format-spec should consume the input or end with a '}'", STR("{: }"), P(nullptr));
+
+ // *** alternate form ***
+ check_exception("The format-spec should consume the input or end with a '}'", STR("{:#}"), P(nullptr));
+
+ // *** zero-padding ***
+ check_exception("A format-spec width field shouldn't have a leading zero", STR("{:0}"), P(nullptr));
+
+ // *** precision ***
+ check_exception("The format-spec should consume the input or end with a '}'", STR("{:.}"), P(nullptr));
+
+ // *** locale-specific form ***
+ check_exception("The format-spec should consume the input or end with a '}'", STR("{:L}"), P(nullptr));
+
+ // *** type ***
+ for (const auto& fmt : invalid_types<CharT>("p"))
+ 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_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 ***
@@ -2611,6 +2652,12 @@ void format_tests(TestFunction check, ExceptionTest check_exception) {
check(STR("hello 42"), STR("hello {}"), static_cast<double>(42));
check(STR("hello 42"), STR("hello {}"), static_cast<long double>(42));
format_test_floating_point<CharT>(check, check_exception);
+
+ // *** Test pointer formater argument ***
+ check(STR("hello 0x0"), STR("hello {}"), nullptr);
+ check(STR("hello 0x42"), STR("hello {}"), reinterpret_cast<void*>(0x42));
+ check(STR("hello 0x42"), STR("hello {}"), reinterpret_cast<const void*>(0x42));
+ format_test_pointer<CharT>(check, check_exception);
}
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
More information about the libcxx-commits
mailing list