mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-28 07:36:06 +00:00
Code Issues Projects Releases Wiki Activity
llvm-project/libcxx/include/__format/formatter_bool.h

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

78 lines
2.6 KiB
C
Raw Normal View History

[libc++][format] Adds bool formatter. Implements the formatter for Boolean types. [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - P1868 width: clarifying units of width and precision in std::format Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D103670
2020-12-14 17:39:15 +01:00
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___FORMAT_FORMATTER_BOOL_H
#define _LIBCPP___FORMAT_FORMATTER_BOOL_H
[libc++] Granularize __string Reviewed By: ldionne, #libc Spies: libcxx-commits, mgorny Differential Revision: https://reviews.llvm.org/D127156
2022-06-06 23:35:24 +02:00
#include <__algorithm/copy.h>
[libc++] Add missing include to fix no-localization CI
2023-07-10 09:58:49 -04:00
#include <__assert>
[libc++][format] Adds bool formatter. Implements the formatter for Boolean types. [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - P1868 width: clarifying units of width and precision in std::format Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D103670
2020-12-14 17:39:15 +01:00
#include <__availability>
#include <__config>
[NFC][libc++][format] Renames __char_type concept. Move the concept to the concepts header and uses a name in the style of P2286. Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D131176
2022-08-04 17:54:20 +02:00
#include <__format/concepts.h>
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-28 18:48:04 +01:00
#include <__format/format_parse_context.h>
[libc++][format] Adds bool formatter. Implements the formatter for Boolean types. [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - P1868 width: clarifying units of width and precision in std::format Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D103670
2020-12-14 17:39:15 +01:00
#include <__format/formatter.h>
#include <__format/formatter_integral.h>
#include <__format/parser_std_format_spec.h>
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-28 18:48:04 +01:00
#include <__utility/unreachable.h>
[libc++][format] Adds bool formatter. Implements the formatter for Boolean types. [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - P1868 width: clarifying units of width and precision in std::format Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D103670
2020-12-14 17:39:15 +01:00
#ifndef _LIBCPP_HAS_NO_LOCALIZATION
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-28 18:48:04 +01:00
# include <locale>
[libc++][format] Adds bool formatter. Implements the formatter for Boolean types. [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - P1868 width: clarifying units of width and precision in std::format Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D103670
2020-12-14 17:39:15 +01:00
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
[libc++] Normalize all our '#pragma GCC system_header', and regression-test. Now we'll notice if a header forgets to include this magic phrase. Differential Revision: https://reviews.llvm.org/D118800
2022-02-01 20:16:40 -05:00
# pragma GCC system_header
[libc++][format] Adds bool formatter. Implements the formatter for Boolean types. [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - P1868 width: clarifying units of width and precision in std::format Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D103670
2020-12-14 17:39:15 +01:00
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
[libc++][NFC] Replace _LIBCPP_STD_VER > x with _LIBCPP_STD_VER >= x This change is almost fully mechanical. The only interesting change is in `generate_feature_test_macro_components.py` to generate `_LIBCPP_STD_VER >=` instead. To avoid churn in the git-blame this commit should be added to the `.git-blame-ignore-revs` once committed. Reviewed By: ldionne, var-const, #libc Spies: jloser, libcxx-commits, arichardson, arphaman, wenlei Differential Revision: https://reviews.llvm.org/D143962
2023-02-14 00:56:09 +01:00
#if _LIBCPP_STD_VER >= 20
[libc++][format] Adds bool formatter. Implements the formatter for Boolean types. [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - P1868 width: clarifying units of width and precision in std::format Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D103670
2020-12-14 17:39:15 +01:00
[NFC][libc++][format] Renames __char_type concept. Move the concept to the concepts header and uses a name in the style of P2286. Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D131176
2022-08-04 17:54:20 +02:00
template <__fmt_char_type _CharT>
[libc++] Remove availability markup for std::format std::format is currently experimental, so there is technically no deployment target requirement for it (since the only symbols required for it are in `libc++experimental.a`). However, some parts of std::format depend indirectly on the floating point std::to_chars implementation, which does have deployment target requirements. This patch removes all the availability format for std::format and updates the XFAILs in the tests to properly explain why they fail on old deployment targets, when they do. It also changes a couple of tests to avoid depending on floating-point std::to_chars when it isn't fundamental to the test. Finally, some tests are marked as XFAIL but I added a comment saying TODO FMT This test should not require std::to_chars(floating-point) These tests do not fundamentally depend on floating-point std::to_chars, however they end up failing because calling std::format even without a floating-point argument to format will end up requiring floating-point std::to_chars. I believe this is an implementation artifact that could be avoided in all cases where we know the format string at compile-time. In the tests, I added the TODO comment only to the places where we could do better and actually avoid relying on floating-point std::to_chars because we know the format string at compile-time. Differential Revision: https://reviews.llvm.org/D134598
2023-03-16 13:09:44 -04:00
struct _LIBCPP_TEMPLATE_VIS formatter<bool, _CharT> {
[libc++][format] Adds bool formatter. Implements the formatter for Boolean types. [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - P1868 width: clarifying units of width and precision in std::format Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D103670
2020-12-14 17:39:15 +01:00
public:
[NFC][libc++][format] Uses uniform member signatures. The newer formatters for (tuple, vector<bool>::reference) specify the formatter's parse and format member function. This signature is slightly different from the signature for existing formatters. Adapt the existing formatters to the new style. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D150034
2023-05-06 13:28:46 +02:00
template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_integral);
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-28 18:48:04 +01:00
__format_spec::__process_parsed_bool(__parser_);
return __result;
}
[libc++][format] Adds bool formatter. Implements the formatter for Boolean types. [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - P1868 width: clarifying units of width and precision in std::format Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D103670
2020-12-14 17:39:15 +01:00
[NFC][libc++][format] Uses uniform member signatures. The newer formatters for (tuple, vector<bool>::reference) specify the formatter's parse and format member function. This signature is slightly different from the signature for existing formatters. Adapt the existing formatters to the new style. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D150034
2023-05-06 13:28:46 +02:00
template <class _FormatContext>
_LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(bool __value, _FormatContext& __ctx) const {
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-28 18:48:04 +01:00
switch (__parser_.__type_) {
[libc++][format] Improves parsing speed. A format string like "{}" is quite common. In this case avoid parsing the format-spec when it's not present. Before the parsing was always called, therefore some refactoring is done to make sure the formatters work properly when their parse member isn't called. From the wording it's not entirely clear whether this optimization is allowed [tab:formatter] ``` and the range [pc.begin(), pc.end()) from the last call to f.parse(pc). ``` Implies there's always a call to `f.parse` even when the format-spec isn't present. Therefore this optimization isn't done for handle classes; it's unclear whether that would break user defined formatters. The improvements give a small reduciton is code size: 719408 12472 488 732368 b2cd0 before 718824 12472 488 731784 b2a88 after The performance benefits when not using a format-spec are: ``` Comparing ./formatter_int.libcxx.out-baseline to ./formatter_int.libcxx.out Benchmark Time CPU Time Old Time New CPU Old CPU New ---------------------------------------------------------------------------------------------------------------------------------------------------- BM_Basic<uint32_t> -0.0688 -0.0687 67 62 67 62 BM_Basic<int32_t> -0.1105 -0.1107 73 65 73 65 BM_Basic<uint64_t> -0.1053 -0.1049 95 85 95 85 BM_Basic<int64_t> -0.0889 -0.0888 93 85 93 85 BM_BasicLow<__uint128_t> -0.0655 -0.0655 96 90 96 90 BM_BasicLow<__int128_t> -0.0693 -0.0694 97 90 97 90 BM_Basic<__uint128_t> -0.0359 -0.0359 256 247 256 247 BM_Basic<__int128_t> -0.0414 -0.0414 239 229 239 229 ``` For the cases where a format-spec is used the results remain similar, some are faster some are slower, differing per run. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D129426
2022-07-09 16:14:40 +02:00
case __format_spec::__type::__default:
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-28 18:48:04 +01:00
case __format_spec::__type::__string:
return __formatter::__format_bool(__value, __ctx, __parser_.__get_parsed_std_specifications(__ctx));
case __format_spec::__type::__binary_lower_case:
case __format_spec::__type::__binary_upper_case:
case __format_spec::__type::__octal:
case __format_spec::__type::__decimal:
case __format_spec::__type::__hexadecimal_lower_case:
case __format_spec::__type::__hexadecimal_upper_case:
// Promotes bool to an integral type. This reduces the number of
// instantiations of __format_integer reducing code size.
return __formatter::__format_integer(
static_cast<unsigned>(__value), __ctx, __parser_.__get_parsed_std_specifications(__ctx));
[libc++][format] Adds bool formatter. Implements the formatter for Boolean types. [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - P1868 width: clarifying units of width and precision in std::format Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D103670
2020-12-14 17:39:15 +01:00
default:
[libc++][hardening][NFC] Introduce `_LIBCPP_ASSERT_UNCATEGORIZED`. Replace most uses of `_LIBCPP_ASSERT` with `_LIBCPP_ASSERT_UNCATEGORIZED`. This is done as a prerequisite to introducing hardened mode to libc++. The idea is to make enabling assertions an opt-in with (somewhat) fine-grained controls over which categories of assertions are enabled. The vast majority of assertions are currently uncategorized; the new macro will allow turning on `_LIBCPP_ASSERT` (the underlying mechanism for all kinds of assertions) without enabling all the uncategorized assertions (in the future; this patch preserves the current behavior). Differential Revision: https://reviews.llvm.org/D153816
2023-06-27 16:40:39 -07:00
_LIBCPP_ASSERT_UNCATEGORIZED(false, "The parse function should have validated the type");
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-28 18:48:04 +01:00
__libcpp_unreachable();
[libc++][format] Adds bool formatter. Implements the formatter for Boolean types. [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - P1868 width: clarifying units of width and precision in std::format Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D103670
2020-12-14 17:39:15 +01:00
}
}
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-28 18:48:04 +01:00
__format_spec::__parser<_CharT> __parser_;
[libc++][format] Adds bool formatter. Implements the formatter for Boolean types. [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - P1868 width: clarifying units of width and precision in std::format Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D103670
2020-12-14 17:39:15 +01:00
};
[libc++][NFC] Replace _LIBCPP_STD_VER > x with _LIBCPP_STD_VER >= x This change is almost fully mechanical. The only interesting change is in `generate_feature_test_macro_components.py` to generate `_LIBCPP_STD_VER >=` instead. To avoid churn in the git-blame this commit should be added to the `.git-blame-ignore-revs` once committed. Reviewed By: ldionne, var-const, #libc Spies: jloser, libcxx-commits, arichardson, arphaman, wenlei Differential Revision: https://reviews.llvm.org/D143962
2023-02-14 00:56:09 +01:00
#endif //_LIBCPP_STD_VER >= 20
[libc++][format] Adds bool formatter. Implements the formatter for Boolean types. [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - P1868 width: clarifying units of width and precision in std::format Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D103670
2020-12-14 17:39:15 +01:00
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMATTER_BOOL_H
Reference in New Issue Copy Permalink