This is an archive of the discontinued LLVM Phabricator instance.

Differential D103433

[libc++][format] Adds integer formatter.
ClosedPublic

Authored by Mordante on May 31 2021, 10:39 PM.

Details

Reviewers
curdeius
ldionne
miscco
vitaut
Group Reviewers
Restricted Project
Commits
rG3e9689d72cdf: [libc++][format] Adds integer formatter.
Summary

Implements the formatter for all fundamental integer types
(except char, wchar_t, and bool).
[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.

As an extension it adds partial support for 128-bit integer types.

Implements parts of:

  • P0645 Text Formatting
  • P1652 Printf corner cases in std::format

Completes:

  • LWG-3248 #b, #B, #o, #x, and #X presentation types misformat negative numbers

Diff Detail

Event Timeline

Mordante created this revision.May 31 2021, 10:39 PM
Herald added a subscriber: mgorny. · View Herald TranscriptMay 31 2021, 10:39 PM
Mordante requested review of this revision.May 31 2021, 10:39 PM
Herald added a project: Restricted Project. · View Herald TranscriptMay 31 2021, 10:39 PM
Herald added a reviewer: Restricted Project. · View Herald TranscriptMay 31 2021, 10:39 PM
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Harbormaster completed remote builds in B106972: Diff 348880.May 31 2021, 11:01 PM
Mordante updated this revision to Diff 348884.May 31 2021, 11:01 PM

Adds a required inline, fixes the build issue.

Harbormaster completed remote builds in B106976: Diff 348884.Jun 1 2021, 1:41 AM
Mordante updated this revision to Diff 348982.Jun 1 2021, 8:20 AM

Cast to the proper signedness that should fix the AArch and ARM builds.

Mordante added a child revision: D103466: [libc++][format] Adds char formatter..Jun 1 2021, 9:20 AM
Harbormaster completed remote builds in B107046: Diff 348982.Jun 1 2021, 9:51 AM
Mordante updated this revision to Diff 349658.Jun 3 2021, 12:44 PM
  • Rebase
  • Fix octal buffer size off by 1.
  • Add test for maximum integral values.
  • Fixes Windows issue
  • Polishing
Harbormaster completed remote builds in B107536: Diff 349658.Jun 3 2021, 2:32 PM
Mordante edited the summary of this revision. (Show Details)Jun 5 2021, 4:16 AM
Mordante added reviewers: curdeius, ldionne, miscco, vitaut.
Mordante mentioned this in D103425: [libc++][format] Adds string formatter..Jun 29 2021, 10:20 AM
Mordante updated this revision to Diff 355451.Jun 29 2021, 11:02 PM
Mordante edited the summary of this revision. (Show Details)

Rebased and updated:

  • Address some changes from previous patches
  • Minor cleanups and comment improvements
  • Added a module map
Harbormaster completed remote builds in B111684: Diff 355451.Jun 30 2021, 12:32 AM
Mordante updated this revision to Diff 357284.Jul 8 2021, 10:59 AM

Rebase.

Harbormaster completed remote builds in B113035: Diff 357284.Jul 8 2021, 4:52 PM
Mordante mentioned this in D96664: [libc++][format] Implement formatters..Jul 11 2021, 6:14 AM
vitaut requested changes to this revision.Jul 17 2021, 8:48 AM
vitaut added inline comments.
libcxx/include/__format/formatter_integer.h
112–117

AFAICS to_chars supports 128-bit integers (https://godbolt.org/z/7GTPrcq88) or am I missing something?

libcxx/include/__format/formatter_integral.h
72

Did you mean "combining"?

89

Why not make these protected to keep the public API of formatter specializations clean?

137

Here and elsewhere the default alignment should depend on the presentation type: http://eel.is/c++draft/format#tab:format.align

i.e. format("{:10}", true) is left-aligned while format("{:10d}", true) is right-aligned.

232

#ifdef can be omitted because there is nothing that use std::locale in __determine_grouping. It will just be unused if locales are disabled.

305

Why store __negative instead of passing it as an argument to __format_unsigned_integral?

315

nit: I'd rename it to __format_as_char because __value is not a char but an integer which we convert and format as char.

316–317

Isn't the alignment supposed to be resolved at parse time by calling __handle_char / __handle_bool?

330

_CharT is already signed so make_signed_t doesn't do anything. Did you mean make_unsigned_t?

libcxx/test/std/utilities/format/format.functions/tests.inc
392–393

Per my earlier comment this should indeed be left-aligned.

This revision now requires changes to proceed.Jul 17 2021, 8:48 AM
vitaut added inline comments.Jul 18 2021, 6:13 AM
libcxx/include/__format/formatter_integral.h
549

In general formatters should only contain information derived from the format string, not from the value. Among other things this would inhibit format string compilation in the future. Please remove.

Mordante marked 11 inline comments as done.Jul 18 2021, 9:42 AM

Thanks for the review!

libcxx/include/__format/formatter_integer.h
112–117

libc++ accepts 128-bit integers, but silently truncates them to 64-bit. IMO this is a bug and it's on my TODO to fix this.
It's visible in the generated assembly, it contains a`std::1::itoa::__pow10_64` lookup table instead of a std::__1::__itoa::__pow10_128.

libcxx/include/__format/formatter_integral.h
89

Good catch!

137

This function is only called when a char is used for the char representation is selected.
Only the __handle_integer is used slightly different. That was basically done to use different formatting for
format("{:6c}", 42) and format("{:6}", '*'). But I'll adjust __handle_integer.

See my response to https://reviews.llvm.org/D103433/new/#inline-1010793 for more information.

305

Basically to avoid passing an argument to a forwarding function. IMO both are a valid design choice. But as you mention in another comment "Among other things this would inhibit format string compilation in the future. Please remove.". So I'll apply your suggestion.

316–317

Only partly, not for integers formatted as char. But I'll adjust this.

See my response to https://reviews.llvm.org/D103433/new/#inline-1010793 for more information.

330

Should indeed be make_unsigned_t. Odd the compiler doesn't complain about a useless cast.

libcxx/test/std/utilities/format/format.functions/tests.inc
392–393

I assumed that was intended. However my interpretation of the wording requires it to be right aligned:
This is the default for arithmetic types other than charT and bool or when an integer presentation type is specified.
My interpretation is that the supplied type in an aritmetic type, so this rule applies.
Do you agree with my interpretation?

I agree it's silly that the result of format("{:6c}", 42); differs from the result of format("{:6}", '*');. So I'll adjust it.

Mordante updated this revision to Diff 359633.Jul 18 2021, 9:44 AM
Mordante marked 7 inline comments as done.

Rebase
Addresses review comments
Contrain the formatter to the allowed character types
Use private module headers
Guard unit tests for implementation details

Harbormaster completed remote builds in B114742: Diff 359633.Jul 18 2021, 10:43 AM
• Quuxplusone added a subscriber: • Quuxplusone.Jul 18 2021, 1:38 PM
• Quuxplusone added inline comments.
libcxx/include/__format/formatter_integer.h
112–117

That is definitely a bug; see https://godbolt.org/z/j9r7YG8aq where there's a discontinuity at base=10 (but I think all the other outputs are correct, probably?). It could be quickly patched like this:

diff --git a/libcxx/include/charconv b/libcxx/include/charconv
index 4a5c65df7c75..74b8993cf392 100644
--- a/libcxx/include/charconv
+++ b/libcxx/include/charconv
@@ -351,6 +351,9 @@ _LIBCPP_AVAILABILITY_TO_CHARS
 inline _LIBCPP_INLINE_VISIBILITY to_chars_result
 __to_chars_itoa(char* __first, char* __last, _Tp __value, false_type)
 {
+    if (sizeof(_Tp) > 8) {
+      return __to_chars_integral(__first, __last, __value, 10, false_type());
+
     using __tx = __itoa::__traits<_Tp>;
     auto __diff = __last - __first;
 
@@ -426,7 +429,7 @@ inline _LIBCPP_INLINE_VISIBILITY to_chars_result
 __to_chars_integral(char* __first, char* __last, _Tp __value, int __base,
                     false_type)
 {
-  if (__base == 10)
+  if (__base == 10 && sizeof(_Tp) <= 8)
     return __to_chars_itoa(__first, __last, __value, false_type());
 
   ptrdiff_t __cap = __last - __first;

But we'd have to add test coverage too.

Mordante marked an inline comment as done.Jul 19 2021, 10:59 AM
Mordante added inline comments.
libcxx/include/__format/formatter_integer.h
112–117

Since we've been shipping this implementation of std::to_chars for a while I didn't have a lot of urgency to fix it. I still want to address this issue later. I've identified more issues with <charconv> and I want to look at these later. For now I want to focus on the formatting library, but <charconv> is still high on my list. Of course if you want to implement this work around feel free to do so; I would be happy to review it.

Mordante marked an inline comment as done.Jul 20 2021, 10:14 AM
Mordante added inline comments.
libcxx/include/__format/formatter.h
152

s/_LIBCPP_INLINE_VISIBILITY/_LIBCPP_HIDE_FROM_ABI/ here and all other occurrences in this patch.

vitaut accepted this revision.Jul 25 2021, 8:27 AM

Looks good, thanks for addressing the comments.

libcxx/test/std/utilities/format/format.functions/tests.inc
392–393

Yeah, I think P1652 missed this part of the wording. The interpretation depends on whether you look at the original types or types after conversion per presentation specifiers. I suggest opening an LWG issue to clarify that we want the latter.

Mordante planned changes to this revision.Jul 30 2021, 4:22 AM
Mordante marked an inline comment as not done.

Needs updates due to changes in D103368.

Mordante updated this revision to Diff 364405.Aug 5 2021, 3:52 AM

Rebased and adjusted for changes in main
Retarget for LLVM 14
s/_LIBCPP_INLINE_VISIBILITY/_LIBCPP_HIDE_FROM_ABI/
Remove nodiscard
Remove obsolete unit test
Generate private module tests

Harbormaster completed remote builds in B118119: Diff 364405.Aug 5 2021, 5:11 AM
vitaut added a comment.Aug 8 2021, 8:47 AM

LGTM

libcxx/include/__format/formatter_integral.h
78–79

I suggest removing the "For example the 128-bit integral formatters use the 64-bit version to do the formatting." because it's a workaround that will go away per TODO in format(__int128_t __value, auto& __ctx) rendering this example wrong. In general I don't think there is a good reason for one specialization to reuse another.

314–320

Why not use a conditional expression?

return __format_unsigned_integral(__array.begin(), __array.end(),
                                  __value, __negative, 8, __ctx, __value != 0 ? "0" : nullptr);
364–365

Maybe add a TODO to format upper-case hex in one pass? As a nice side effect you could probably also kill dependency on <algorithm> which is super bloated in 20.

Mordante added inline comments.Aug 8 2021, 12:50 PM
libcxx/include/__format/formatter_integral.h
78–79

Valid point and I think the 128-bit work-around is the only place it's used.

314–320

No specific reason not to use it. But in this case looks better with the conditional expression.

364–365

I'll add a TODO. I'm not sure I'll be able to remove <algorithm>, I use more parts of it. But I can have a look to use the new smaller <__algorithm/foo.h> headers. That's something that has been worked on after my initial version of this patch.

Mordante updated this revision to Diff 365527.Aug 10 2021, 10:06 AM
Mordante marked 4 inline comments as done.

Addresses review comments.

Harbormaster completed remote builds in B118927: Diff 365527.Aug 10 2021, 12:58 PM
Mordante updated this revision to Diff 370735.Sep 4 2021, 5:52 AM

Rebased and adjusted for changes in main
s/_LIBCPP_INLINE_VISIBILITY/_LIBCPP_HIDE_FROM_ABI/

Harbormaster completed remote builds in B122626: Diff 370735.Sep 4 2021, 6:55 AM
Mordante updated this revision to Diff 372760.Sep 15 2021, 11:26 AM

Rebased and updated to changes in earlier commits in the series.

Harbormaster completed remote builds in B124052: Diff 372760.Sep 15 2021, 12:15 PM
Mordante updated this revision to Diff 372950.Sep 16 2021, 8:02 AM

Rebased.

Harbormaster completed remote builds in B124198: Diff 372950.Sep 16 2021, 9:12 AM
ldionne accepted this revision.Oct 6 2021, 12:17 PM
ldionne added inline comments.
libcxx/include/__format/formatter_integer.h
112–117

Can we file a bug report to track this work item? I'm fearful we'll forget about it forever otherwise.

libcxx/include/__format/formatter_integral.h
490

This block is long enough that we can't easily see what #if the #endif relates to.

This revision is now accepted and ready to land.Oct 6 2021, 12:17 PM
Mordante marked an inline comment as done.Oct 6 2021, 12:31 PM
Mordante added inline comments.
libcxx/include/__format/formatter_integer.h
112–117

I've marked it as TODO's in the format related files, for example line 151 in this file
// TODO FMT Implement full 128 bit support.

So I don't fear we'll forget it. I don't consider format fully implemented before these TODO FMTs are resolved.

Mordante marked 2 inline comments as done.Oct 7 2021, 8:07 AM
Closed by commit rG3e9689d72cdf: [libc++][format] Adds integer formatter. (authored by Mordante). · Explain WhyOct 7 2021, 8:08 AM
This revision was automatically updated to reflect the committed changes.
Mordante added a commit: rG3e9689d72cdf: [libc++][format] Adds integer formatter..
androm3da mentioned this in D113597: [libcxx] Change the type of __size to match __width.Nov 10 2021, 11:08 AM

Revision Contents

PathSize
libcxx/
docs/
2 lines
2 lines
include/
2 lines
__format/
24 lines
170 lines
561 lines
63 lines
2 lines
test/
std/
utilities/
format/
format.functions/
567 lines
330 lines
format.string/
format.string.std/
21 lines
242 lines

Diff 355451

libcxx/docs/Cxx2aStatusIssuesStatus.csv

Show First 20 Lines • Show All 199 Lines • ▼ Show 20 Lines
"`3201 <https://wg21.link/LWG3201>`__","``lerp``\ should be marked as ``noexcept``\ ","Prague","|Complete|","" "`3201 <https://wg21.link/LWG3201>`__","``lerp``\ should be marked as ``noexcept``\ ","Prague","|Complete|",""
"`3226 <https://wg21.link/LWG3226>`__","``zoned_time``\ constructor from ``string_view``\ should accept ``zoned_time<Duration2, TimeZonePtr2>``\ ","Prague","","" "`3226 <https://wg21.link/LWG3226>`__","``zoned_time``\ constructor from ``string_view``\ should accept ``zoned_time<Duration2, TimeZonePtr2>``\ ","Prague","",""
"`3233 <https://wg21.link/LWG3233>`__","Broken requirements for ``shared_ptr``\ converting constructors","Prague","","" "`3233 <https://wg21.link/LWG3233>`__","Broken requirements for ``shared_ptr``\ converting constructors","Prague","",""
"`3237 <https://wg21.link/LWG3237>`__","LWG 3038 and 3190 have inconsistent PRs","Prague","","" "`3237 <https://wg21.link/LWG3237>`__","LWG 3038 and 3190 have inconsistent PRs","Prague","",""
"`3238 <https://wg21.link/LWG3238>`__","Insufficiently-defined behavior of ``std::function``\ deduction guides","Prague","","" "`3238 <https://wg21.link/LWG3238>`__","Insufficiently-defined behavior of ``std::function``\ deduction guides","Prague","",""
"`3242 <https://wg21.link/LWG3242>`__","``std::format``\ : missing rules for ``arg-id``\ in ``width``\ and ``precision``\ ","Prague","|Complete|","Clang 13" "`3242 <https://wg21.link/LWG3242>`__","``std::format``\ : missing rules for ``arg-id``\ in ``width``\ and ``precision``\ ","Prague","|Complete|","Clang 13"
"`3243 <https://wg21.link/LWG3243>`__","``std::format``\ and negative zeroes","Prague","","" "`3243 <https://wg21.link/LWG3243>`__","``std::format``\ and negative zeroes","Prague","",""
"`3247 <https://wg21.link/LWG3247>`__","``ranges::iter_move``\ should perform ADL-only lookup of ``iter_move``\ ","Prague","","" "`3247 <https://wg21.link/LWG3247>`__","``ranges::iter_move``\ should perform ADL-only lookup of ``iter_move``\ ","Prague","",""
"`3248 <https://wg21.link/LWG3248>`__","``std::format``\ ``#b``\ , ``#B``\ , ``#o``\ , ``#x``\ , and ``#X``\ presentation types misformat negative numbers","Prague","","" "`3248 <https://wg21.link/LWG3248>`__","``std::format``\ ``#b``\ , ``#B``\ , ``#o``\ , ``#x``\ , and ``#X``\ presentation types misformat negative numbers","Prague","|Complete|","13.0"
"`3250 <https://wg21.link/LWG3250>`__","``std::format``\ : ``#``\ (alternate form) for NaN and inf","Prague","","" "`3250 <https://wg21.link/LWG3250>`__","``std::format``\ : ``#``\ (alternate form) for NaN and inf","Prague","",""
"`3251 <https://wg21.link/LWG3251>`__","Are ``std::format``\ alignment specifiers applied to string arguments?","Prague","","" "`3251 <https://wg21.link/LWG3251>`__","Are ``std::format``\ alignment specifiers applied to string arguments?","Prague","",""
"`3252 <https://wg21.link/LWG3252>`__","Parse locale's aware modifiers for commands are not consistent with POSIX spec","Prague","","" "`3252 <https://wg21.link/LWG3252>`__","Parse locale's aware modifiers for commands are not consistent with POSIX spec","Prague","",""
"`3254 <https://wg21.link/LWG3254>`__","Strike ``stop_token``\ 's ``operator!=``\ ","Prague","","" "`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|","" "`3255 <https://wg21.link/LWG3255>`__","``span``\ 's ``array``\ constructor is too strict","Prague","|Complete|",""
"`3260 <https://wg21.link/LWG3260>`__","``year_month*``\ arithmetic rejects durations convertible to years","Prague","","" "`3260 <https://wg21.link/LWG3260>`__","``year_month*``\ arithmetic rejects durations convertible to years","Prague","",""
"`3262 <https://wg21.link/LWG3262>`__","Formatting of negative durations is not specified","Prague","","" "`3262 <https://wg21.link/LWG3262>`__","Formatting of negative durations is not specified","Prague","",""
"`3264 <https://wg21.link/LWG3264>`__","``sized_range``\ and ``ranges::size``\ redundantly use ``disable_sized_range``\ ","Prague","","" "`3264 <https://wg21.link/LWG3264>`__","``sized_range``\ and ``ranges::size``\ redundantly use ``disable_sized_range``\ ","Prague","",""
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

libcxx/docs/Cxx2aStatusPaperStatus.csv

Show First 20 Lines • Show All 123 Lines • ▼ Show 20 Lines
"`P1523 <https://wg21.link/P1523>`__","LWG","Views and Size Types","Cologne","","" "`P1523 <https://wg21.link/P1523>`__","LWG","Views and Size Types","Cologne","",""
"`P1612 <https://wg21.link/P1612>`__","LWG","Relocate Endian's Specification","Cologne","|Complete|","10.0" "`P1612 <https://wg21.link/P1612>`__","LWG","Relocate Endian's Specification","Cologne","|Complete|","10.0"
"`P1614 <https://wg21.link/P1614>`__","LWG","The Mothership has Landed","Cologne","|In Progress|","" "`P1614 <https://wg21.link/P1614>`__","LWG","The Mothership has Landed","Cologne","|In Progress|",""
"`P1638 <https://wg21.link/P1638>`__","LWG","basic_istream_view::iterator should not be copyable","Cologne","","" "`P1638 <https://wg21.link/P1638>`__","LWG","basic_istream_view::iterator should not be copyable","Cologne","",""
"`P1643 <https://wg21.link/P1643>`__","LWG","Add wait/notify to atomic_ref","Cologne","","" "`P1643 <https://wg21.link/P1643>`__","LWG","Add wait/notify to atomic_ref","Cologne","",""
"`P1644 <https://wg21.link/P1644>`__","LWG","Add wait/notify to atomic<shared_ptr>","Cologne","","" "`P1644 <https://wg21.link/P1644>`__","LWG","Add wait/notify to atomic<shared_ptr>","Cologne","",""
"`P1650 <https://wg21.link/P1650>`__","LWG","Output std::chrono::days with 'd' suffix","Cologne","","" "`P1650 <https://wg21.link/P1650>`__","LWG","Output std::chrono::days with 'd' suffix","Cologne","",""
"`P1651 <https://wg21.link/P1651>`__","LWG","bind_front should not unwrap reference_wrapper","Cologne","|Complete|","13.0" "`P1651 <https://wg21.link/P1651>`__","LWG","bind_front should not unwrap reference_wrapper","Cologne","|Complete|","13.0"
"`P1652 <https://wg21.link/P1652>`__","LWG","Printf corner cases in std::format","Cologne","","" "`P1652 <https://wg21.link/P1652>`__","LWG","Printf corner cases in std::format","Cologne","|In Progress|",""
"`P1661 <https://wg21.link/P1661>`__","LWG","Remove dedicated precalculated hash lookup interface","Cologne","|Nothing To Do|","" "`P1661 <https://wg21.link/P1661>`__","LWG","Remove dedicated precalculated hash lookup interface","Cologne","|Nothing To Do|",""
"`P1754 <https://wg21.link/P1754>`__","LWG","Rename concepts to standard_case for C++20, while we still can","Cologne","|In Progress|","" "`P1754 <https://wg21.link/P1754>`__","LWG","Rename concepts to standard_case for C++20, while we still can","Cologne","|In Progress|",""
"","","","","","" "","","","","",""
"`P0883 <https://wg21.link/P0883>`__","LWG","Fixing Atomic Initialization","Belfast","|Complete| [#note-P0883]","13.0" "`P0883 <https://wg21.link/P0883>`__","LWG","Fixing Atomic Initialization","Belfast","|Complete| [#note-P0883]","13.0"
"`P1391 <https://wg21.link/P1391>`__","LWG","Range constructor for std::string_view","Belfast","* *","" "`P1391 <https://wg21.link/P1391>`__","LWG","Range constructor for std::string_view","Belfast","* *",""
"`P1394 <https://wg21.link/P1394>`__","LWG","Range constructor for std::span","Belfast","* *","" "`P1394 <https://wg21.link/P1394>`__","LWG","Range constructor for std::span","Belfast","* *",""
"`P1456 <https://wg21.link/P1456>`__","LWG","Move-only views","Belfast","* *","" "`P1456 <https://wg21.link/P1456>`__","LWG","Move-only views","Belfast","* *",""
"`P1622 <https://wg21.link/P1622>`__","LWG","Mandating the Standard Library: Clause 32 - Thread support library","Belfast","* *","" "`P1622 <https://wg21.link/P1622>`__","LWG","Mandating the Standard Library: Clause 32 - Thread support library","Belfast","* *",""
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

libcxx/include/CMakeLists.txt

Show First 20 Lines • Show All 102 Lines • ▼ Show 20 Linesset(files
__format/format_arg.h __format/format_arg.h
__format/format_args.h __format/format_args.h
__format/format_context.h __format/format_context.h
__format/format_error.h __format/format_error.h
__format/format_fwd.h __format/format_fwd.h
__format/format_parse_context.h __format/format_parse_context.h
__format/format_string.h __format/format_string.h
__format/formatter.h __format/formatter.h
__format/formatter_integer.h
__format/formatter_integral.h
__format/formatter_string.h __format/formatter_string.h
__format/parser_std_format_spec.h __format/parser_std_format_spec.h
__function_like.h __function_like.h
__functional/search.h __functional/search.h
__functional_03 __functional_03
__functional_base __functional_base
__functional_base_03 __functional_base_03
__functional/hash.h __functional/hash.h
▲ Show 20 Lines • Show All 285 Lines • Show Last 20 Lines

libcxx/include/__format/formatter.h

Show First 20 Lines • Show All 136 Lines • ▼ Show 20 Lines__write(__output_iterator<const _CharT&> auto __out_it, const _CharT* __first,
__padding_size_result __padding = __padding_size_result __padding =
__padding_size(__size, __width, __alignment); __padding_size(__size, __width, __alignment);
__out_it = _VSTD::fill_n(_VSTD::move(__out_it), __padding.__before, __fill); __out_it = _VSTD::fill_n(_VSTD::move(__out_it), __padding.__before, __fill);
__out_it = _VSTD::copy(__first, __last, _VSTD::move(__out_it)); __out_it = _VSTD::copy(__first, __last, _VSTD::move(__out_it));
return _VSTD::fill_n(_VSTD::move(__out_it), __padding.__after, __fill); return _VSTD::fill_n(_VSTD::move(__out_it), __padding.__after, __fill);
} }
/** /**
* @overload
*
* Uses a transformation operation before writing an element.
*
* TODO FMT Fill will probably change to support Unicode grapheme cluster.
*/
template <class _CharT, class _UnaryOperation, class _Fill>
[[nodiscard]] _LIBCPP_INLINE_VISIBILITY auto
MordanteAuthorUnsubmitted
Done
ReplyInline Actions

s/_LIBCPP_INLINE_VISIBILITY/_LIBCPP_HIDE_FROM_ABI/ here and all other occurrences in this patch.

Mordante: `s/_LIBCPP_INLINE_VISIBILITY/_LIBCPP_HIDE_FROM_ABI/` here and all other occurrences in this…
__write(__output_iterator<const _CharT&> auto __out_it, const _CharT* __first,
const _CharT* __last, size_t __size, _UnaryOperation __op,
size_t __width, _Fill __fill,
__format_spec::_Flags::_Alignment __alignment) -> decltype(__out_it) {
_LIBCPP_ASSERT(__first <= __last, "Not a valid range");
_LIBCPP_ASSERT(__size < __width, "Precondition failure");
__padding_size_result __padding =
__padding_size(__size, __width, __alignment);
__out_it = _VSTD::fill_n(_VSTD::move(__out_it), __padding.__before, __fill);
__out_it = _VSTD::transform(__first, __last, _VSTD::move(__out_it), __op);
return _VSTD::fill_n(_VSTD::move(__out_it), __padding.__after, __fill);
}
/**
* Writes Unicode input to the output with the required padding. * Writes Unicode input to the output with the required padding.
* *
* This function does almost the same as the @ref __write function, but handles * This function does almost the same as the @ref __write function, but handles
* the width estimation of the Unicode input. * the width estimation of the Unicode input.
* *
* @param __str The range [@a __first, @a __last). * @param __str The range [@a __first, @a __last).
* @param __precision The width to truncate the input string to, use @c -1 for * @param __precision The width to truncate the input string to, use @c -1 for
* no limit. * no limit.
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libcxx/include/__format/formatter_integer.h

  • This file was added.
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___FORMAT_FORMATTER_INTEGER_H
#define _LIBCPP___FORMAT_FORMATTER_INTEGER_H
#include <__availability>
#include <__config>
#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 <limits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_PUSH_MACROS
#include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17
// 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) && \
!defined(_LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED)
namespace __format_spec {
template <class _CharT>
class _LIBCPP_TEMPLATE_VIS __parser_integer : public __parser_integral<_CharT> {
public:
using _Base = __parser_integral<_CharT>;
_LIBCPP_INLINE_VISIBILITY constexpr auto parse(auto& __parse_ctx)
-> decltype(__parse_ctx.begin()) {
auto __it = _Base::parse(__parse_ctx);
this->__handle_integer();
switch (this->__type) {
case _Flags::_Type::__default:
this->__type = _Flags::_Type::__decimal;
break;
case _Flags::_Type::__binary_lower_case:
case _Flags::_Type::__binary_upper_case:
case _Flags::_Type::__char:
case _Flags::_Type::__octal:
case _Flags::_Type::__decimal:
case _Flags::_Type::__hexadecimal_lower_case:
case _Flags::_Type::__hexadecimal_upper_case:
break;
default:
__throw_format_error("The format-spec type has a type not supported for "
"an integer argument");
}
return __it;
}
};
template <class _CharT>
using __formatter_integer = __formatter_integral<__parser_integer<_CharT>>;
} // namespace __format_spec
// [format.formatter.spec]/2.3
// For each charT, for each cv-unqualified arithmetic type ArithmeticT other
// than char, wchar_t, char8_t, char16_t, or char32_t, a specialization
// Signed integral types.
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
formatter<signed char, _CharT>
: public __format_spec::__formatter_integer<_CharT> {};
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<short, _CharT>
: public __format_spec::__formatter_integer<_CharT> {};
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<int, _CharT>
: public __format_spec::__formatter_integer<_CharT> {};
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<long, _CharT>
: public __format_spec::__formatter_integer<_CharT> {};
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
formatter<long long, _CharT>
: public __format_spec::__formatter_integer<_CharT> {};
#ifndef _LIBCPP_HAS_NO_INT128
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
formatter<__int128_t, _CharT>
: public __format_spec::__formatter_integer<_CharT> {
using _Base = __format_spec::__formatter_integer<_CharT>;
_LIBCPP_INLINE_VISIBILITY auto format(__int128_t __value, auto& __ctx)
-> decltype(__ctx.out()) {
// TODO FMT Implement full 128 bit support.
using _To = long long;
if (__value < numeric_limits<_To>::min() ||
__value > numeric_limits<_To>::max())
__throw_format_error("128 bit value is outside of implemented range");
return _Base::format(static_cast<_To>(__value), __ctx);
}
vitautUnsubmitted
Done
ReplyInline Actions

AFAICS to_chars supports 128-bit integers (https://godbolt.org/z/7GTPrcq88) or am I missing something?

vitaut: AFAICS `to_chars` supports 128-bit integers (https://godbolt.org/z/7GTPrcq88) or am I missing…
MordanteAuthorUnsubmitted
Done
ReplyInline Actions

libc++ accepts 128-bit integers, but silently truncates them to 64-bit. IMO this is a bug and it's on my TODO to fix this.
It's visible in the generated assembly, it contains a`std::1::itoa::__pow10_64` lookup table instead of a std::__1::__itoa::__pow10_128.

Mordante: libc++ accepts 128-bit integers, but silently truncates them to 64-bit. IMO this is a bug and…
QuuxplusoneUnsubmitted
Done
ReplyInline Actions

That is definitely a bug; see https://godbolt.org/z/j9r7YG8aq where there's a discontinuity at base=10 (but I think all the other outputs are correct, probably?). It could be quickly patched like this:

diff --git a/libcxx/include/charconv b/libcxx/include/charconv
index 4a5c65df7c75..74b8993cf392 100644
--- a/libcxx/include/charconv
+++ b/libcxx/include/charconv
@@ -351,6 +351,9 @@ _LIBCPP_AVAILABILITY_TO_CHARS
 inline _LIBCPP_INLINE_VISIBILITY to_chars_result
 __to_chars_itoa(char* __first, char* __last, _Tp __value, false_type)
 {
+    if (sizeof(_Tp) > 8) {
+      return __to_chars_integral(__first, __last, __value, 10, false_type());
+
     using __tx = __itoa::__traits<_Tp>;
     auto __diff = __last - __first;
 
@@ -426,7 +429,7 @@ inline _LIBCPP_INLINE_VISIBILITY to_chars_result
 __to_chars_integral(char* __first, char* __last, _Tp __value, int __base,
                     false_type)
 {
-  if (__base == 10)
+  if (__base == 10 && sizeof(_Tp) <= 8)
     return __to_chars_itoa(__first, __last, __value, false_type());
 
   ptrdiff_t __cap = __last - __first;

But we'd have to add test coverage too.

Quuxplusone: That is definitely a bug; see https://godbolt.org/z/j9r7YG8aq where there's a discontinuity at…
MordanteAuthorUnsubmitted
Done
ReplyInline Actions

Since we've been shipping this implementation of std::to_chars for a while I didn't have a lot of urgency to fix it. I still want to address this issue later. I've identified more issues with <charconv> and I want to look at these later. For now I want to focus on the formatting library, but <charconv> is still high on my list. Of course if you want to implement this work around feel free to do so; I would be happy to review it.

Mordante: Since we've been shipping this implementation of `std::to_chars` for a while I didn't have a…
ldionneUnsubmitted
Done
ReplyInline Actions

Can we file a bug report to track this work item? I'm fearful we'll forget about it forever otherwise.

ldionne: Can we file a bug report to track this work item? I'm fearful we'll forget about it forever…
MordanteAuthorUnsubmitted
Done
ReplyInline Actions

I've marked it as TODO's in the format related files, for example line 151 in this file
// TODO FMT Implement full 128 bit support.

So I don't fear we'll forget it. I don't consider format fully implemented before these TODO FMTs are resolved.

Mordante: I've marked it as TODO's in the format related files, for example line 151 in this file `//…
};
#endif
// Unsigned integral types.
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
formatter<unsigned char, _CharT>
: public __format_spec::__formatter_integer<_CharT> {};
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
formatter<unsigned short, _CharT>
: public __format_spec::__formatter_integer<_CharT> {};
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
formatter<unsigned, _CharT>
: public __format_spec::__formatter_integer<_CharT> {};
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
formatter<unsigned long, _CharT>
: public __format_spec::__formatter_integer<_CharT> {};
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
formatter<unsigned long long, _CharT>
: public __format_spec::__formatter_integer<_CharT> {};
#ifndef _LIBCPP_HAS_NO_INT128
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
formatter<__uint128_t, _CharT>
: public __format_spec::__formatter_integer<_CharT> {
using _Base = __format_spec::__formatter_integer<_CharT>;
_LIBCPP_INLINE_VISIBILITY auto format(__uint128_t __value, auto& __ctx)
-> decltype(__ctx.out()) {
// TODO FMT Implement full 128 bit support.
using _To = unsigned long long;
if (__value < numeric_limits<_To>::min() ||
__value > numeric_limits<_To>::max())
__throw_format_error("128 bit value is outside of implemented range");
return _Base::format(static_cast<_To>(__value), __ctx);
}
};
#endif
#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS) && !defined(_LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED)
#endif //_LIBCPP_STD_VER > 17
_LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS
#endif // _LIBCPP___FORMAT_FORMATTER_INTEGER_H

libcxx/include/__format/formatter_integral.h

  • This file was added.
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___FORMAT_FORMATTER_INTEGRAL_H
#define _LIBCPP___FORMAT_FORMATTER_INTEGRAL_H
#include <__config>
#include <__format/format_error.h>
#include <__format/format_fwd.h>
#include <__format/formatter.h>
#include <__format/parser_std_format_spec.h>
#include <algorithm>
#include <array>
#include <charconv>
#include <concepts>
#include <limits>
#include <string>
#ifndef _LIBCPP_HAS_NO_LOCALIZATION
#include <locale>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_PUSH_MACROS
#include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17
// 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) && \
!defined(_LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED)
/**
* Integral formatting classes.
*
* There are two types used here:
* * C++-type, the type as used in C++.
* * format-type, the output type specified in the std-format-spec.
*
* Design of the integral formatters consists of several layers.
* * @ref __parser_integral The basic std-format-spec parser for all integral
* classes. This parser does the basic sanity checks. It also contains some
* helper functions that are nice to have available for all parsers.
* * A C++-type specific parser. These parsers must derive from
* @ref __parser_integral. Their task is to validate whether the parsed
* std-format-spec is valid for the C++-type and selected format-type. After
* validation they need to make sure all members are properly set. For
* example, when the alignment hasn't changed it needs to set the proper
* default alignment for the format-type. The following parsers are available:
* - @ref __parser_integer
* - @ref __parser_char
* - @ref __parser_bool
* * A general formatter for all integral types @ref __formatter_integral. This
* formatter can handle all formatting of integers and characters. The class
* derives from the proper formatter.
* Note the boolean string format-type isn't supported in this class.
* * A typedef C++-type group combing the @ref __formatter_integral with a
* parser:
vitautUnsubmitted
Done
ReplyInline Actions

Did you mean "combining"?

vitaut: Did you mean "combining"?
* * @ref __formatter_integer
* * @ref __formatter_char
* * @ref __formatter_bool
* * Then every C++-type has its own formatter specializations. They inherit
* from the C++-type group typedef. Most specializations need nothing else.
* Others need some additional specializations in this class. For example the
* 128-bit integral formatters use the 64-bit version to do the formatting.
vitautUnsubmitted
Done
ReplyInline Actions

I suggest removing the "For example the 128-bit integral formatters use the 64-bit version to do the formatting." because it's a workaround that will go away per TODO in format(__int128_t __value, auto& __ctx) rendering this example wrong. In general I don't think there is a good reason for one specialization to reuse another.

vitaut: I suggest removing the "For example the 128-bit integral formatters use the 64-bit version to…
MordanteAuthorUnsubmitted
Done
ReplyInline Actions

Valid point and I think the 128-bit work-around is the only place it's used.

Mordante: Valid point and I think the 128-bit work-around is the only place it's used.
*/
namespace __format_spec {
template <class _CharT>
class _LIBCPP_TEMPLATE_VIS __parser_integral
: public __parser_std<_CharT, __parser_no_precision, __parser_sign,
__parser_alternate_form, __parser_zero_padding,
__parser_locale_specific_form> {
public:
/**
vitautUnsubmitted
Done
ReplyInline Actions

Why not make these protected to keep the public API of formatter specializations clean?

vitaut: Why not make these protected to keep the public API of `formatter` specializations clean?
MordanteAuthorUnsubmitted
Done
ReplyInline Actions

Good catch!

Mordante: Good catch!
* Handles the post-parsing updates for the integer types.
*
* Updates the zero-padding and alignment for integer types.
*
* [format.string.std]/13
* If the 0 character and an align option both appear, the 0 character is
* ignored.
*
* For the formatter a @ref __default alignment means zero-padding. Update
* the alignment based on parsed format string.
*/
_LIBCPP_INLINE_VISIBILITY constexpr void __handle_integer() noexcept {
this->__zero_padding &= this->__alignment == _Flags::_Alignment::__default;
if (!this->__zero_padding &&
this->__alignment == _Flags::_Alignment::__default)
this->__alignment = _Flags::_Alignment::__right;
}
/**
* Handles the post-parsing updates for the character types.
*
* Sets the alignment and validates the format flags set for a character type.
*
* At the moment the validation for a character and a Boolean behave the
* same, but this may change in the future.
*/
_LIBCPP_INLINE_VISIBILITY constexpr void __handle_char() { __handle_bool(); }
/**
* Handles the post-parsing updates for the Boolean types.
*
* Sets the alignment and validates the format flags set for a Boolean type.
*/
_LIBCPP_INLINE_VISIBILITY constexpr void __handle_bool() {
if (this->__sign != _Flags::_Sign::__default)
__throw_format_error("A sign field isn't allowed in this format-spec");
if (this->__alternate_form)
__throw_format_error(
"An alternate form field isn't allowed in this format-spec");
if (this->__zero_padding)
__throw_format_error(
"A zero-padding field isn't allowed in this format-spec");
if (this->__alignment == _Flags::_Alignment::__default)
this->__alignment = _Flags::_Alignment::__left;
}
vitautUnsubmitted
Done
ReplyInline Actions

Here and elsewhere the default alignment should depend on the presentation type: http://eel.is/c++draft/format#tab:format.align

i.e. format("{:10}", true) is left-aligned while format("{:10d}", true) is right-aligned.

vitaut: Here and elsewhere the default alignment should depend on the presentation type: http://eel.
MordanteAuthorUnsubmitted
Done
ReplyInline Actions

This function is only called when a char is used for the char representation is selected.
Only the __handle_integer is used slightly different. That was basically done to use different formatting for
format("{:6c}", 42) and format("{:6}", '*'). But I'll adjust __handle_integer.

See my response to https://reviews.llvm.org/D103433/new/#inline-1010793 for more information.

Mordante: This function is only called when a char is used for the char representation is selected. Only…
};
/** Wrapper around @ref to_chars, returning the output pointer. */
template <class _Tp>
[[nodiscard]] _LIBCPP_INLINE_VISIBILITY char*
__to_buffer(char* __first, char* __last, _Tp __value, int __base) {
// TODO FMT Evaluate code overhead due to not calling the internal function
// directly. (Should be zero overhead.)
to_chars_result __r = _VSTD::to_chars(__first, __last, __value, __base);
_LIBCPP_ASSERT(__r.ec == errc(0), "Internal buffer too small");
return __r.ptr;
}
/**
* Helper to determine the buffer size to output a integer in Base @em x.
*
* There are several overloads for the supported bases. The function uses the
* base as template argument so it can be used in a constant expression.
*/
template <unsigned_integral _Tp, size_t _Base>
[[nodiscard]] _LIBCPP_INLINE_VISIBILITY constexpr size_t
__buffer_size() noexcept requires(_Base == 2) {
return numeric_limits<_Tp>::digits // The number of binary digits.
+ 2 // Reserve space for the '0[Bb]' prefix.
+ 1; // Reserve space for the sign.
}
template <unsigned_integral _Tp, size_t _Base>
[[nodiscard]] _LIBCPP_INLINE_VISIBILITY constexpr size_t
__buffer_size() noexcept requires(_Base == 8) {
return numeric_limits<_Tp>::digits // The number of binary digits.
/ 3 // Adjust to octal.
+ 1 // Turn floor to ceil.
+ 1 // Reserve space for the '0' prefix.
+ 1; // Reserve space for the sign.
}
template <unsigned_integral _Tp, size_t _Base>
[[nodiscard]] _LIBCPP_INLINE_VISIBILITY constexpr size_t
__buffer_size() noexcept requires(_Base == 10) {
return numeric_limits<_Tp>::digits10 // The floored value.
+ 1 // Turn floor to ceil.
+ 1; // Reserve space for the sign.
}
template <unsigned_integral _Tp, size_t _Base>
[[nodiscard]] _LIBCPP_INLINE_VISIBILITY constexpr size_t
__buffer_size() noexcept requires(_Base == 16) {
return numeric_limits<_Tp>::digits // The number of binary digits.
/ 4 // Adjust to hexadecimal.
+ 2 // Reserve space for the '0[Xx]' prefix.
+ 1; // Reserve space for the sign.
}
[[nodiscard]] _LIBCPP_INLINE_VISIBILITY inline char*
__insert_sign(char* __buf, bool __negative, _Flags::_Sign __sign) {
if (__negative)
*__buf++ = '-';
else
switch (__sign) {
case _Flags::_Sign::__default:
case _Flags::_Sign::__minus:
// No sign added.
break;
case _Flags::_Sign::__plus:
*__buf++ = '+';
break;
case _Flags::_Sign::__space:
*__buf++ = ' ';
break;
}
return __buf;
}
[[nodiscard]] _LIBCPP_INLINE_VISIBILITY constexpr char __hex_to_upper(char c) {
switch (c) {
case 'a':
return 'A';
case 'b':
return 'B';
case 'c':
return 'C';
case 'd':
return 'D';
case 'e':
return 'E';
case 'f':
return 'F';
}
return c;
}
#ifndef _LIBCPP_HAS_NO_LOCALIZATION
/**
vitautUnsubmitted
Done
ReplyInline Actions

#ifdef can be omitted because there is nothing that use std::locale in __determine_grouping. It will just be unused if locales are disabled.

vitaut: `#ifdef` can be omitted because there is nothing that use `std::locale` in…
* Determines the required grouping based on the size of the input.
*
* The grouping's last element will be repeated. For simplicity this repeating
* is unwrapped based on the length of the input. (When the input is short some
* groups are not processed.)
*
* @returns The size of the groups to write. This means the number of
* separator characters written is size() - 1.
*
* @note Since zero-sized groups cause issues they are silently ignored.
*
* @note The grouping field of the locale is always a @c std::string,
* regardless whether the @c std::numpunct's type is @c char or @c wchar_t.
*/
[[nodiscard]] _LIBCPP_INLINE_VISIBILITY inline string
__determine_grouping(ptrdiff_t __size, const string& __grouping) {
_LIBCPP_ASSERT(!__grouping.empty() && __size > __grouping[0],
"The slow grouping formatting is used while there will be no "
"separators written");
string __r;
auto __end = __grouping.end() - 1;
auto __ptr = __grouping.begin();
while (true) {
__size -= *__ptr;
if (__size > 0)
__r.push_back(*__ptr);
else {
// __size <= 0 so the value pushed will be <= *__ptr.
__r.push_back(*__ptr + __size);
return __r;
}
// Proceed to the next group.
if (__ptr != __end) {
do {
++__ptr;
// Skip grouping with a width of 0.
} while (*__ptr == 0 && __ptr != __end);
}
}
_LIBCPP_UNREACHABLE();
}
#endif
template <class _Parser>
class _LIBCPP_TEMPLATE_VIS __formatter_integral : public _Parser {
public:
using _CharT = typename _Parser::char_type;
template <integral _Tp>
_LIBCPP_INLINE_VISIBILITY auto format(_Tp __value, auto& __ctx)
-> decltype(__ctx.out()) {
if (this->__width_needs_substitution())
this->__substitute_width_arg_id(__ctx.arg(this->__width));
if (this->__type == _Flags::_Type::__char)
return __format_char(__value, __ctx);
if constexpr (unsigned_integral<_Tp>)
return __format_unsigned_integral(__value, __ctx);
else {
// Depending on the std-format-spec string the sign and the value
// might not be outputted together:
// - alternate form may insert a prefix string.
// - zero-padding may insert additional '0' characters.
// Therefore the value is processed as a positive unsigned value.
// The function @ref __insert_sign will a '-' when the value was negative.
auto __r = __to_unsigned_like(__value);
if (__value < 0) {
__negative = true;
__r = __complement(__r);
vitautUnsubmitted
Done
ReplyInline Actions

Why store __negative instead of passing it as an argument to __format_unsigned_integral?

vitaut: Why store `__negative` instead of passing it as an argument to `__format_unsigned_integral`?
MordanteAuthorUnsubmitted
Done
ReplyInline Actions

Basically to avoid passing an argument to a forwarding function. IMO both are a valid design choice. But as you mention in another comment "Among other things this would inhibit format string compilation in the future. Please remove.". So I'll apply your suggestion.

Mordante: Basically to avoid passing an argument to a forwarding function. IMO both are a valid design…
}
return __format_unsigned_integral(__r, __ctx);
}
}
private:
/** Generic formatting for format-type c. */
[[nodiscard]] _LIBCPP_INLINE_VISIBILITY auto
__format_char(integral auto __value, auto& __ctx) -> decltype(__ctx.out()) {
if (this->__alignment == _Flags::_Alignment::__default)
vitautUnsubmitted
Done
ReplyInline Actions

nit: I'd rename it to __format_as_char because __value is not a char but an integer which we convert and format as char.

vitaut: nit: I'd rename it to `__format_as_char` because `__value` is not a char but an integer which…
this->__alignment = _Flags::_Alignment::__right;
vitautUnsubmitted
Done
ReplyInline Actions

Isn't the alignment supposed to be resolved at parse time by calling __handle_char / __handle_bool?

vitaut: Isn't the alignment supposed to be resolved at parse time by calling `__handle_char` /…
MordanteAuthorUnsubmitted
Done
ReplyInline Actions

Only partly, not for integers formatted as char. But I'll adjust this.

See my response to https://reviews.llvm.org/D103433/new/#inline-1010793 for more information.

Mordante: Only partly, not for integers formatted as char. But I'll adjust this. See my response to…
using _Tp = decltype(__value);
if constexpr (!same_as<_CharT, _Tp>) {
// cmp_less and cmp_greater can't be used for character types.
vitautUnsubmitted
Done
ReplyInline Actions

Why not use a conditional expression?

return __format_unsigned_integral(__array.begin(), __array.end(),
                                  __value, __negative, 8, __ctx, __value != 0 ? "0" : nullptr);
vitaut: Why not use a conditional expression? ``` return __format_unsigned_integral(__array.
MordanteAuthorUnsubmitted
Done
ReplyInline Actions

No specific reason not to use it. But in this case looks better with the conditional expression.

Mordante: No specific reason not to use it. But in this case looks better with the conditional expression.
if constexpr (signed_integral<_CharT> == signed_integral<_Tp>) {
if (__value < numeric_limits<_CharT>::min() ||
__value > numeric_limits<_CharT>::max())
__throw_format_error(
"Integral value outside the range of the char type");
} else if constexpr (signed_integral<_CharT>) {
// _CharT is signed _Tp is unsigned
if (__value >
static_cast<make_signed_t<_CharT>>(numeric_limits<_CharT>::max()))
__throw_format_error(
vitautUnsubmitted
Done
ReplyInline Actions

_CharT is already signed so make_signed_t doesn't do anything. Did you mean make_unsigned_t?

vitaut: `_CharT` is already signed so `make_signed_t` doesn't do anything. Did you mean…
MordanteAuthorUnsubmitted
Done
ReplyInline Actions

Should indeed be make_unsigned_t. Odd the compiler doesn't complain about a useless cast.

Mordante: Should indeed be `make_unsigned_t`. Odd the compiler doesn't complain about a useless cast.
"Integral value outside the range of the char type");
} else {
// _CharT is unsigned _Tp is signed
if (__value < 0 || static_cast<make_unsigned_t<_Tp>>(__value) >
numeric_limits<_CharT>::max())
__throw_format_error(
"Integral value outside the range of the char type");
}
}
const auto __c = static_cast<_CharT>(__value);
return __write(_VSTD::addressof(__c), _VSTD::addressof(__c) + 1,
__ctx.out());
}
/**
* Generic formatting for format-type bBdoxX.
*
* This small wrapper allocates a buffer with the required size. Then calls
* the real formatter with the buffer and the prefix for the base.
*/
[[nodiscard]] _LIBCPP_INLINE_VISIBILITY auto
__format_unsigned_integral(unsigned_integral auto __value, auto& __ctx)
-> decltype(__ctx.out()) {
switch (this->__type) {
case _Flags::_Type::__binary_lower_case: {
array<char, __buffer_size<decltype(__value), 2>()> __array;
return __format_unsigned_integral(__array.begin(), __array.end(), __value,
2, __ctx, "0b");
}
case _Flags::_Type::__binary_upper_case: {
array<char, __buffer_size<decltype(__value), 2>()> __array;
return __format_unsigned_integral(__array.begin(), __array.end(), __value,
2, __ctx, "0B");
}
vitautUnsubmitted
Done
ReplyInline Actions

Maybe add a TODO to format upper-case hex in one pass? As a nice side effect you could probably also kill dependency on <algorithm> which is super bloated in 20.

vitaut: Maybe add a TODO to format upper-case hex in one pass? As a nice side effect you could probably…
MordanteAuthorUnsubmitted
Done
ReplyInline Actions

I'll add a TODO. I'm not sure I'll be able to remove <algorithm>, I use more parts of it. But I can have a look to use the new smaller <__algorithm/foo.h> headers. That's something that has been worked on after my initial version of this patch.

Mordante: I'll add a TODO. I'm not sure I'll be able to remove `<algorithm>`, I use more parts of it. But…
case _Flags::_Type::__octal: {
// Octal is special; if __value == 0 there's no prefix.
array<char, __buffer_size<decltype(__value), 8>()> __array;
if (__value == 0)
return __format_unsigned_integral(__array.begin(), __array.end(),
__value, 8, __ctx, nullptr);
else
return __format_unsigned_integral(__array.begin(), __array.end(),
__value, 8, __ctx, "0");
}
case _Flags::_Type::__decimal: {
array<char, __buffer_size<decltype(__value), 10>()> __array;
return __format_unsigned_integral(__array.begin(), __array.end(), __value,
10, __ctx, nullptr);
}
case _Flags::_Type::__hexadecimal_lower_case: {
array<char, __buffer_size<decltype(__value), 16>()> __array;
return __format_unsigned_integral(__array.begin(), __array.end(), __value,
16, __ctx, "0x");
}
case _Flags::_Type::__hexadecimal_upper_case: {
array<char, __buffer_size<decltype(__value), 16>()> __array;
return __format_unsigned_integral(__array.begin(), __array.end(), __value,
16, __ctx, "0X");
}
default:
_LIBCPP_ASSERT(false, "The parser should have validated the type");
_LIBCPP_UNREACHABLE();
}
}
template <class _Tp>
requires(same_as<char, _Tp> || same_as<wchar_t, _Tp>)
[[nodiscard]] _LIBCPP_INLINE_VISIBILITY
auto __write(const _Tp* __first, const _Tp* __last, auto __out_it)
-> decltype(__out_it) {
unsigned __size = __last - __first;
if (this->__type != _Flags::_Type::__hexadecimal_upper_case) [[likely]] {
if (__size >= this->__width)
return _VSTD::copy(__first, __last, _VSTD::move(__out_it));
return __formatter::__write(_VSTD::move(__out_it), __first, __last,
__size, this->__width, this->__fill,
this->__alignment);
}
// this->__type == _Flags::_Type::__hexadecimal_upper_case
// This means all characters in the range [a-f] need to be changed to their
// uppercase representation. The transformation is done as transformation
// in the output routine instead of before. This avoids another pass over
// the data.
if (__size >= this->__width)
return _VSTD::transform(__first, __last, _VSTD::move(__out_it),
__hex_to_upper);
return __formatter::__write(_VSTD::move(__out_it), __first, __last, __size,
__hex_to_upper, this->__width, this->__fill,
this->__alignment);
}
[[nodiscard]] _LIBCPP_INLINE_VISIBILITY auto __format_unsigned_integral(
char* __begin, char* __end, unsigned_integral auto __value, int __base,
auto& __ctx, const char* __prefix) -> decltype(__ctx.out()) {
char* __first = __insert_sign(__begin, __negative, this->__sign);
if (this->__alternate_form && __prefix)
while (*__prefix)
*__first++ = *__prefix++;
char* __last = __to_buffer(__first, __end, __value, __base);
#ifndef _LIBCPP_HAS_NO_LOCALIZATION
if (this->__locale_specific_form) {
const auto& __np = use_facet<numpunct<_CharT>>(__ctx.locale());
string __grouping = __np.grouping();
ptrdiff_t __size = __last - __first;
// Writing the grouped form has more overhead than the normal output
// routines. If there will be no separators written the locale-specific
// form is identical to the normal routine. Test whether to grouped form
// is required.
if (!__grouping.empty() && __size > __grouping[0])
return __format_grouping(__ctx.out(), __begin, __first, __last,
__determine_grouping(__size, __grouping),
__np.thousands_sep());
}
#endif
auto __out_it = __ctx.out();
if (this->__alignment != _Flags::_Alignment::__default)
__first = __begin;
else {
// __buf contains [sign][prefix]data
// ^ location of __first
// The zero padding is done like:
// - Write [sign][prefix]
// - Write data right aligned with '0' as fill character.
__out_it = _VSTD::copy(__begin, __first, _VSTD::move(__out_it));
this->__alignment = _Flags::_Alignment::__right;
this->__fill = _CharT('0');
unsigned __size = __first - __begin;
this->__width -= _VSTD::min(__size, this->__width);
}
return __write(__first, __last, _VSTD::move(__out_it));
}
#ifndef _LIBCPP_HAS_NO_LOCALIZATION
/** Format's the locale-specific form's groupings. */
template <class _OutIt, class _CharT>
[[nodiscard]] _LIBCPP_INLINE_VISIBILITY _OutIt
__format_grouping(_OutIt __out_it, const char* __begin, const char* __first,
const char* __last, string&& __grouping, _CharT __sep) {
// TODO FMT This function duplicates some functionality of the normal
// output routines. Evaluate whether these parts can be efficiently
// combined with the existing routines.
unsigned __size = (__first - __begin) + // [sign][prefix]
(__last - __first) + // data
(__grouping.size() - 1); // number of separator characters
__formatter::__padding_size_result __padding = {0, 0};
if (this->__alignment == _Flags::_Alignment::__default) {
// Write [sign][prefix].
__out_it = _VSTD::copy(__begin, __first, _VSTD::move(__out_it));
if (this->__width > __size) {
ldionneUnsubmitted
Done
ReplyInline Actions
this->__fill);
}
- #endif
+ #endif // _LIBCPP_HAS_NO_LOCALIZATION
};
} // namespace __format_spec

This block is long enough that we can't easily see what #if the #endif relates to.

ldionne: This block is long enough that we can't easily see what `#if` the `#endif` relates to.
// Write zero padding.
__padding.__before = this->__width - __size;
__out_it = _VSTD::fill_n(_VSTD::move(__out_it), this->__width - __size,
_CharT('0'));
}
} else {
if (this->__width > __size) {
// Determine padding and write padding.
__padding = __formatter::__padding_size(__size, this->__width,
this->__alignment);
__out_it = _VSTD::fill_n(_VSTD::move(__out_it), __padding.__before,
this->__fill);
}
// Write [sign][prefix].
__out_it = _VSTD::copy(__begin, __first, _VSTD::move(__out_it));
}
auto __r = __grouping.rbegin();
auto __e = __grouping.rend() - 1;
_LIBCPP_ASSERT(__r != __e, "The slow grouping formatting is used while "
"there will be no separators written.");
// The output is divided in small groups of numbers to write:
// - A group before the first separator.
// - A separator and a group, repeated for the number of separators.
// - A group after the last separator.
// This loop achieves that process by testing the termination condition
// midway in the loop.
//
// TODO FMT This loop evaluates the loop invariant `this->__type !=
// _Flags::_Type::__hexadecimal_upper_case` for every iteration. (This test
// happens in the __write call.) Benchmark whether making two loops and
// hoisting the invariant is worth the effort.
while (true) {
if (this->__type == _Flags::_Type::__hexadecimal_upper_case) {
__last = __first + *__r;
__out_it = _VSTD::transform(__first, __last, _VSTD::move(__out_it),
__hex_to_upper);
__first = __last;
} else {
__out_it = _VSTD::copy_n(__first, *__r, _VSTD::move(__out_it));
__first += *__r;
}
if (__r == __e)
break;
++__r;
*__out_it++ = __sep;
}
return _VSTD::fill_n(_VSTD::move(__out_it), __padding.__after,
this->__fill);
}
#endif
private:
bool __negative{false};
};
vitautUnsubmitted
Done
ReplyInline Actions

In general formatters should only contain information derived from the format string, not from the value. Among other things this would inhibit format string compilation in the future. Please remove.

vitaut: In general formatters should only contain information derived from the format string, not from…
} // namespace __format_spec
#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS) && !defined(_LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED)
#endif //_LIBCPP_STD_VER > 17
_LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS
#endif // _LIBCPP___FORMAT_FORMATTER_INTEGRAL_H

libcxx/include/format

Show First 20 Lines • Show All 273 Lines • ▼ Show 20 Lines
*/ */
#include <__config> #include <__config>
#include <__debug> #include <__debug>
#include <__format/format_arg.h> #include <__format/format_arg.h>
#include <__format/format_args.h> #include <__format/format_args.h>
#include <__format/format_context.h> #include <__format/format_context.h>
#include <__format/format_error.h> #include <__format/format_error.h>
#include <__format/format_fwd.h>
#include <__format/format_parse_context.h> #include <__format/format_parse_context.h>
#include <__format/format_string.h> #include <__format/format_string.h>
#include <__format/formatter.h> #include <__format/formatter.h>
#include <__format/formatter_integer.h>
#include <__format/formatter_string.h> #include <__format/formatter_string.h>
#include <__format/parser_std_format_spec.h> #include <__format/parser_std_format_spec.h>
#include <array> #include <array>
#include <concepts> #include <concepts>
#include <string> #include <string>
#include <string_view> #include <string_view>
#include <type_traits> #include <type_traits>
#include <variant> // TODO FMT Use <__variant/monostate.h> #include <variant> // TODO FMT Use <__variant/monostate.h>
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Linesprivate:
_LIBCPP_HIDDEN static wstring _LIBCPP_HIDDEN static wstring
__convert(_Uv __value) requires(same_as<_CharT, wchar_t>) { __convert(_Uv __value) requires(same_as<_CharT, wchar_t>) {
return _VSTD::to_wstring(__value); return _VSTD::to_wstring(__value);
} }
template <class _Uv> template <class _Uv>
_LIBCPP_HIDDEN auto __handle_format(_Uv __value, auto& __ctx) _LIBCPP_HIDDEN auto __handle_format(_Uv __value, auto& __ctx)
-> decltype(__ctx.out()) -> decltype(__ctx.out())
#ifndef _LIBCPP_HAS_NO_INT128
requires(!same_as<_Uv, __int128_t> && !same_as<_Uv, __uint128_t>)
#endif
{ {
// TODO FMT Implement using formatting arguments // TODO FMT Implement using formatting arguments
// TODO FMT Improve PoC since using std::to_string is inefficient. // TODO FMT Improve PoC since using std::to_string is inefficient.
// Note the code doesn't use std::string::iterator since the unit tests // Note the code doesn't use std::string::iterator since the unit tests
// test with debug iterators and they fail with strings created from // test with debug iterators and they fail with strings created from
// std::to_string. // std::to_string.
auto __str = __convert(__value); auto __str = __convert(__value);
auto __out_it = __ctx.out(); auto __out_it = __ctx.out();
for (size_t __i = 0, __e = __str.size(); __i != __e; ++__i) for (size_t __i = 0, __e = __str.size(); __i != __e; ++__i)
*__out_it++ = __str[__i]; *__out_it++ = __str[__i];
return __out_it; return __out_it;
} }
#ifndef _LIBCPP_HAS_NO_INT128
template <class _Uv>
_LIBCPP_HIDDEN auto __handle_format(_Uv __value, auto& __ctx)
-> decltype(__ctx.out()) requires(same_as<_Uv, __int128_t> ||
same_as<_Uv, __uint128_t>) {
using _To = conditional_t<is_signed_v<_Uv>, long long, unsigned long long>;
// TODO FMT Implement full 128 bit support.
if (__value < numeric_limits<_To>::min() ||
__value > numeric_limits<_To>::max())
__throw_format_error("128 bit value is outside of implemented range");
return __handle_format(static_cast<_To>(__value), __ctx);
}
#endif
}; };
} // namespace __format } // namespace __format
// These specializations are helper stubs and not proper formatters. // These specializations are helper stubs and not proper formatters.
// TODO FMT Implement the proper formatter specializations. // TODO FMT Implement the proper formatter specializations.
// [format.formatter.spec]/2.1 The specializations // [format.formatter.spec]/2.1 The specializations
Show All 26 Linesstruct _LIBCPP_TEMPLATE_VIS formatter<bool, _CharT> {
auto format(bool __b, auto& __ctx) -> decltype(__ctx.out()) { auto format(bool __b, auto& __ctx) -> decltype(__ctx.out()) {
// TODO FMT Implement using formatting arguments // TODO FMT Implement using formatting arguments
auto __out_it = __ctx.out(); auto __out_it = __ctx.out();
*__out_it++ = _CharT('0') + __b; *__out_it++ = _CharT('0') + __b;
return __out_it; return __out_it;
} }
}; };
// Signed integral types.
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<signed char, _CharT>
: public __format::__formatter_arithmetic<signed char, _CharT> {};
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<short, _CharT>
: public __format::__formatter_arithmetic<short, _CharT> {};
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<int, _CharT>
: public __format::__formatter_arithmetic<int, _CharT> {};
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<long, _CharT>
: public __format::__formatter_arithmetic<long, _CharT> {};
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<long long, _CharT>
: public __format::__formatter_arithmetic<long long, _CharT> {};
#ifndef _LIBCPP_HAS_NO_INT128
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<__int128_t, _CharT>
: public __format::__formatter_arithmetic<__int128_t, _CharT> {};
#endif
// Unsigned integral types.
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<unsigned char, _CharT>
: public __format::__formatter_arithmetic<unsigned char, _CharT> {};
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<unsigned short, _CharT>
: public __format::__formatter_arithmetic<unsigned short, _CharT> {};
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<unsigned, _CharT>
: public __format::__formatter_arithmetic<unsigned, _CharT> {};
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<unsigned long, _CharT>
: public __format::__formatter_arithmetic<unsigned long, _CharT> {};
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<unsigned long long, _CharT>
: public __format::__formatter_arithmetic<unsigned long long, _CharT> {};
#ifndef _LIBCPP_HAS_NO_INT128
template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<__uint128_t, _CharT>
: public __format::__formatter_arithmetic<__uint128_t, _CharT> {};
#endif
// Floating point types. // Floating point types.
template <class _CharT> template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<float, _CharT> struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<float, _CharT>
: public __format::__formatter_arithmetic<float, _CharT> {}; : public __format::__formatter_arithmetic<float, _CharT> {};
template <class _CharT> template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
formatter<double, _CharT> formatter<double, _CharT>
: public __format::__formatter_arithmetic<double, _CharT> {}; : public __format::__formatter_arithmetic<double, _CharT> {};
▲ Show 20 Lines • Show All 331 Lines • Show Last 20 Lines

libcxx/include/module.modulemap

Show First 20 Lines • Show All 397 Lines • ▼ Show 20 Lines module __format {
export optional export optional
export locale export locale
} }
module format_error { header "__format/format_error.h" } module format_error { header "__format/format_error.h" }
module format_fwd { header "__format/format_fwd.h" } module format_fwd { header "__format/format_fwd.h" }
module format_parse_context { header "__format/format_parse_context.h" } module format_parse_context { header "__format/format_parse_context.h" }
module format_string { header "__format/format_string.h" } module format_string { header "__format/format_string.h" }
module formatter { header "__format/formatter.h" } module formatter { header "__format/formatter.h" }
module formatter_integer { header "__format/formatter_integer.h" }
module formatter_integral { header "__format/formatter_integral.h" }
module formatter_string { header "__format/formatter_string.h" } module formatter_string { header "__format/formatter_string.h" }
module parser_std_format_spec { header "__format/parser_std_format_spec.h" } module parser_std_format_spec { header "__format/parser_std_format_spec.h" }
} }
} }
module forward_list { module forward_list {
header "forward_list" header "forward_list"
export initializer_list export initializer_list
export * export *
▲ Show 20 Lines • Show All 425 Lines • Show Last 20 Lines

libcxx/test/std/utilities/format/format.functions/locale-specific_form.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
// 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-localization
// REQUIRES: locale.en_US.UTF-8
// <format>
// This test the locale-specific form for these formatting functions:
//
// // [format.functions], formatting functions
// template<class... Args>
// string format(string_view fmt, const Args&... args);
// template<class... Args>
// wstring format(wstring_view fmt, const Args&... args);
// template<class... Args>
// string format(const locale& loc, string_view fmt, const Args&... args);
// template<class... Args>
// wstring format(const locale& loc, wstring_view fmt, const Args&... args);
//
// string vformat(string_view fmt, format_args args);
// wstring vformat(wstring_view fmt, wformat_args args);
// string vformat(const locale& loc, string_view fmt, format_args args);
// wstring vformat(const locale& loc, wstring_view fmt, wformat_args args);
//
// template<class Out, class... Args>
// Out format_to(Out out, string_view fmt, const Args&... args);
// template<class Out, class... Args>
// Out format_to(Out out, wstring_view fmt, const Args&... args);
// template<class Out, class... Args>
// Out format_to(Out out, const locale& loc, string_view fmt, const Args&... args);
// template<class Out, class... Args>
// Out format_to(Out out, const locale& loc, wstring_view fmt, const Args&... args);
//
// template<class Out>
// Out vformat_to(Out out, string_view fmt,
// format_args_t<type_identity_t<Out>, char> args);
// template<class Out>
// Out vformat_to(Out out, wstring_view fmt,
// format_args_t<type_identity_t<Out>, wchar_t> args);
// template<class Out>
// Out vformat_to(Out out, const locale& loc, string_view fmt,
// format_args_t<type_identity_t<Out>, char> args);
// template<class Out>
// Out vformat_to(Out out, const locale& loc, wstring_view fmt,
// format_args_t<type_identity_t<Out>, wchar_t> args);
//
// template<class Out> struct format_to_n_result {
// Out out;
// iter_difference_t<Out> size;
// };
//
// template<class Out, class... Args>
// format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
// string_view fmt, const Args&... args);
// template<class Out, class... Args>
// format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
// wstring_view fmt, const Args&... args);
// template<class Out, class... Args>
// format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
// const locale& loc, string_view fmt,
// const Args&... args);
// template<class Out, class... Args>
// format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
// const locale& loc, wstring_view fmt,
// const Args&... args);
//
// template<class... Args>
// size_t formatted_size(string_view fmt, const Args&... args);
// template<class... Args>
// size_t formatted_size(wstring_view fmt, const Args&... args);
// template<class... Args>
// size_t formatted_size(const locale& loc, string_view fmt, const Args&... args);
// template<class... Args>
// size_t formatted_size(const locale& loc, wstring_view fmt, const Args&... args);
#include <format>
#include <cassert>
#include <iostream>
#include <vector>
#include "test_macros.h"
#include "make_string.h"
#include "platform_support.h" // locale name macros
#define STR(S) MAKE_STRING(CharT, S)
template <class CharT>
struct numpunct;
template <>
struct numpunct<char> : std::numpunct<char> {
string_type do_truename() const override { return "yes"; }
string_type do_falsename() const override { return "no"; }
std::string do_grouping() const override { return "\1\2\3\2\1"; };
char do_thousands_sep() const override { return '_'; }
};
template <>
struct numpunct<wchar_t> : std::numpunct<wchar_t> {
string_type do_truename() const override { return L"yes"; }
string_type do_falsename() const override { return L"no"; }
std::string do_grouping() const override { return "\1\2\3\2\1"; };
wchar_t do_thousands_sep() const override { return L'_'; }
};
template <class CharT, class... Args>
void test(std::basic_string<CharT> expected, std::basic_string<CharT> fmt,
const Args&... args) {
// *** format ***
{
std::basic_string<CharT> out = std::format(fmt, args...);
if constexpr (std::same_as<CharT, char>)
if (out != expected)
std::cerr << "\nFormat string " << fmt << "\nExpected output "
<< expected << "\nActual output " << out << '\n';
assert(out == expected);
}
// *** vformat ***
{
std::basic_string<CharT> out = std::vformat(
fmt, std::make_format_args<std::basic_format_context<
std::back_insert_iterator<std::basic_string<CharT>>, CharT>>(
args...));
assert(out == expected);
}
// *** format_to ***
{
std::basic_string<CharT> out(expected.size(), CharT(' '));
auto it = std::format_to(out.begin(), fmt, args...);
assert(it == out.end());
assert(out == expected);
}
// *** vformat_to ***
{
std::basic_string<CharT> out(expected.size(), CharT(' '));
auto it = std::vformat_to(
out.begin(), fmt,
std::make_format_args<std::basic_format_context<
typename std::basic_string<CharT>::iterator, CharT>>(args...));
assert(it == out.end());
assert(out == expected);
}
// *** format_to_n ***
{
std::basic_string<CharT> out;
std::format_to_n_result result =
std::format_to_n(std::back_inserter(out), 1000, fmt, args...);
using diff_type = decltype(result.size);
diff_type formatted_size = std::formatted_size(fmt, args...);
diff_type size = std::min<diff_type>(1000, formatted_size);
assert(result.size == formatted_size);
assert(out == expected.substr(0, size));
}
// *** formatted_size ***
{
size_t size = std::formatted_size(fmt, args...);
assert(size == expected.size());
}
}
template <class CharT, class... Args>
void test(std::basic_string<CharT> expected, std::locale loc,
std::basic_string<CharT> fmt, const Args&... args) {
// *** format ***
{
std::basic_string<CharT> out = std::format(loc, fmt, args...);
if constexpr (std::same_as<CharT, char>)
if (out != expected)
std::cerr << "\nFormat string " << fmt << "\nExpected output "
<< expected << "\nActual output " << out << '\n';
assert(out == expected);
}
// *** vformat ***
{
std::basic_string<CharT> out = std::vformat(
loc, fmt,
std::make_format_args<std::basic_format_context<
std::back_insert_iterator<std::basic_string<CharT>>, CharT>>(
args...));
assert(out == expected);
}
// *** format_to ***
{
std::basic_string<CharT> out(expected.size(), CharT(' '));
auto it = std::format_to(out.begin(), loc, fmt, args...);
assert(it == out.end());
assert(out == expected);
}
// *** vformat_to ***
{
std::basic_string<CharT> out(expected.size(), CharT(' '));
auto it = std::vformat_to(
out.begin(), loc, fmt,
std::make_format_args<std::basic_format_context<
typename std::basic_string<CharT>::iterator, CharT>>(args...));
assert(it == out.end());
assert(out == expected);
}
// *** format_to_n ***
{
std::basic_string<CharT> out;
std::format_to_n_result result =
std::format_to_n(std::back_inserter(out), 1000, loc, fmt, args...);
using diff_type = decltype(result.size);
diff_type formatted_size = std::formatted_size(loc, fmt, args...);
diff_type size = std::min<diff_type>(1000, formatted_size);
assert(result.size == formatted_size);
assert(out == expected.substr(0, size));
}
// *** formatted_size ***
{
size_t size = std::formatted_size(loc, fmt, args...);
assert(size == expected.size());
}
}
template <class CharT>
void test_integer() {
std::locale loc = std::locale(std::locale(), new numpunct<CharT>());
std::locale en_US = std::locale(LOCALE_en_US_UTF_8);
// *** Decimal ***
std::locale::global(en_US);
test(STR("0"), STR("{:L}"), 0);
test(STR("1"), STR("{:L}"), 1);
test(STR("10"), STR("{:L}"), 10);
test(STR("100"), STR("{:L}"), 100);
test(STR("1,000"), STR("{:L}"), 1'000);
test(STR("10,000"), STR("{:L}"), 10'000);
test(STR("100,000"), STR("{:L}"), 100'000);
test(STR("1,000,000"), STR("{:L}"), 1'000'000);
test(STR("10,000,000"), STR("{:L}"), 10'000'000);
test(STR("100,000,000"), STR("{:L}"), 100'000'000);
test(STR("1,000,000,000"), STR("{:L}"), 1'000'000'000);
test(STR("-1"), STR("{:L}"), -1);
test(STR("-10"), STR("{:L}"), -10);
test(STR("-100"), STR("{:L}"), -100);
test(STR("-1,000"), STR("{:L}"), -1'000);
test(STR("-10,000"), STR("{:L}"), -10'000);
test(STR("-100,000"), STR("{:L}"), -100'000);
test(STR("-1,000,000"), STR("{:L}"), -1'000'000);
test(STR("-10,000,000"), STR("{:L}"), -10'000'000);
test(STR("-100,000,000"), STR("{:L}"), -100'000'000);
test(STR("-1,000,000,000"), STR("{:L}"), -1'000'000'000);
std::locale::global(loc);
test(STR("0"), STR("{:L}"), 0);
test(STR("1"), STR("{:L}"), 1);
test(STR("1_0"), STR("{:L}"), 10);
test(STR("10_0"), STR("{:L}"), 100);
test(STR("1_00_0"), STR("{:L}"), 1'000);
test(STR("10_00_0"), STR("{:L}"), 10'000);
test(STR("100_00_0"), STR("{:L}"), 100'000);
test(STR("1_000_00_0"), STR("{:L}"), 1'000'000);
test(STR("10_000_00_0"), STR("{:L}"), 10'000'000);
test(STR("1_00_000_00_0"), STR("{:L}"), 100'000'000);
test(STR("1_0_00_000_00_0"), STR("{:L}"), 1'000'000'000);
test(STR("-1"), STR("{:L}"), -1);
test(STR("-1_0"), STR("{:L}"), -10);
test(STR("-10_0"), STR("{:L}"), -100);
test(STR("-1_00_0"), STR("{:L}"), -1'000);
test(STR("-10_00_0"), STR("{:L}"), -10'000);
test(STR("-100_00_0"), STR("{:L}"), -100'000);
test(STR("-1_000_00_0"), STR("{:L}"), -1'000'000);
test(STR("-10_000_00_0"), STR("{:L}"), -10'000'000);
test(STR("-1_00_000_00_0"), STR("{:L}"), -100'000'000);
test(STR("-1_0_00_000_00_0"), STR("{:L}"), -1'000'000'000);
test(STR("0"), en_US, STR("{:L}"), 0);
test(STR("1"), en_US, STR("{:L}"), 1);
test(STR("10"), en_US, STR("{:L}"), 10);
test(STR("100"), en_US, STR("{:L}"), 100);
test(STR("1,000"), en_US, STR("{:L}"), 1'000);
test(STR("10,000"), en_US, STR("{:L}"), 10'000);
test(STR("100,000"), en_US, STR("{:L}"), 100'000);
test(STR("1,000,000"), en_US, STR("{:L}"), 1'000'000);
test(STR("10,000,000"), en_US, STR("{:L}"), 10'000'000);
test(STR("100,000,000"), en_US, STR("{:L}"), 100'000'000);
test(STR("1,000,000,000"), en_US, STR("{:L}"), 1'000'000'000);
test(STR("-1"), en_US, STR("{:L}"), -1);
test(STR("-10"), en_US, STR("{:L}"), -10);
test(STR("-100"), en_US, STR("{:L}"), -100);
test(STR("-1,000"), en_US, STR("{:L}"), -1'000);
test(STR("-10,000"), en_US, STR("{:L}"), -10'000);
test(STR("-100,000"), en_US, STR("{:L}"), -100'000);
test(STR("-1,000,000"), en_US, STR("{:L}"), -1'000'000);
test(STR("-10,000,000"), en_US, STR("{:L}"), -10'000'000);
test(STR("-100,000,000"), en_US, STR("{:L}"), -100'000'000);
test(STR("-1,000,000,000"), en_US, STR("{:L}"), -1'000'000'000);
std::locale::global(en_US);
test(STR("0"), loc, STR("{:L}"), 0);
test(STR("1"), loc, STR("{:L}"), 1);
test(STR("1_0"), loc, STR("{:L}"), 10);
test(STR("10_0"), loc, STR("{:L}"), 100);
test(STR("1_00_0"), loc, STR("{:L}"), 1'000);
test(STR("10_00_0"), loc, STR("{:L}"), 10'000);
test(STR("100_00_0"), loc, STR("{:L}"), 100'000);
test(STR("1_000_00_0"), loc, STR("{:L}"), 1'000'000);
test(STR("10_000_00_0"), loc, STR("{:L}"), 10'000'000);
test(STR("1_00_000_00_0"), loc, STR("{:L}"), 100'000'000);
test(STR("1_0_00_000_00_0"), loc, STR("{:L}"), 1'000'000'000);
test(STR("-1"), loc, STR("{:L}"), -1);
test(STR("-1_0"), loc, STR("{:L}"), -10);
test(STR("-10_0"), loc, STR("{:L}"), -100);
test(STR("-1_00_0"), loc, STR("{:L}"), -1'000);
test(STR("-10_00_0"), loc, STR("{:L}"), -10'000);
test(STR("-100_00_0"), loc, STR("{:L}"), -100'000);
test(STR("-1_000_00_0"), loc, STR("{:L}"), -1'000'000);
test(STR("-10_000_00_0"), loc, STR("{:L}"), -10'000'000);
test(STR("-1_00_000_00_0"), loc, STR("{:L}"), -100'000'000);
test(STR("-1_0_00_000_00_0"), loc, STR("{:L}"), -1'000'000'000);
// *** Binary ***
std::locale::global(en_US);
test(STR("0"), STR("{:Lb}"), 0b0);
test(STR("1"), STR("{:Lb}"), 0b1);
test(STR("1,000,000,000"), STR("{:Lb}"), 0b1'000'000'000);
test(STR("0b0"), STR("{:#Lb}"), 0b0);
test(STR("0b1"), STR("{:#Lb}"), 0b1);
test(STR("0b1,000,000,000"), STR("{:#Lb}"), 0b1'000'000'000);
test(STR("-1"), STR("{:LB}"), -0b1);
test(STR("-1,000,000,000"), STR("{:LB}"), -0b1'000'000'000);
test(STR("-0B1"), STR("{:#LB}"), -0b1);
test(STR("-0B1,000,000,000"), STR("{:#LB}"), -0b1'000'000'000);
std::locale::global(loc);
test(STR("0"), STR("{:Lb}"), 0b0);
test(STR("1"), STR("{:Lb}"), 0b1);
test(STR("1_0_00_000_00_0"), STR("{:Lb}"), 0b1'000'000'000);
test(STR("0b0"), STR("{:#Lb}"), 0b0);
test(STR("0b1"), STR("{:#Lb}"), 0b1);
test(STR("0b1_0_00_000_00_0"), STR("{:#Lb}"), 0b1'000'000'000);
test(STR("-1"), STR("{:LB}"), -0b1);
test(STR("-1_0_00_000_00_0"), STR("{:LB}"), -0b1'000'000'000);
test(STR("-0B1"), STR("{:#LB}"), -0b1);
test(STR("-0B1_0_00_000_00_0"), STR("{:#LB}"), -0b1'000'000'000);
test(STR("0"), en_US, STR("{:Lb}"), 0b0);
test(STR("1"), en_US, STR("{:Lb}"), 0b1);
test(STR("1,000,000,000"), en_US, STR("{:Lb}"), 0b1'000'000'000);
test(STR("0b0"), en_US, STR("{:#Lb}"), 0b0);
test(STR("0b1"), en_US, STR("{:#Lb}"), 0b1);
test(STR("0b1,000,000,000"), en_US, STR("{:#Lb}"), 0b1'000'000'000);
test(STR("-1"), en_US, STR("{:LB}"), -0b1);
test(STR("-1,000,000,000"), en_US, STR("{:LB}"), -0b1'000'000'000);
test(STR("-0B1"), en_US, STR("{:#LB}"), -0b1);
test(STR("-0B1,000,000,000"), en_US, STR("{:#LB}"), -0b1'000'000'000);
std::locale::global(en_US);
test(STR("0"), loc, STR("{:Lb}"), 0b0);
test(STR("1"), loc, STR("{:Lb}"), 0b1);
test(STR("1_0_00_000_00_0"), loc, STR("{:Lb}"), 0b1'000'000'000);
test(STR("0b0"), loc, STR("{:#Lb}"), 0b0);
test(STR("0b1"), loc, STR("{:#Lb}"), 0b1);
test(STR("0b1_0_00_000_00_0"), loc, STR("{:#Lb}"), 0b1'000'000'000);
test(STR("-1"), loc, STR("{:LB}"), -0b1);
test(STR("-1_0_00_000_00_0"), loc, STR("{:LB}"), -0b1'000'000'000);
test(STR("-0B1"), loc, STR("{:#LB}"), -0b1);
test(STR("-0B1_0_00_000_00_0"), loc, STR("{:#LB}"), -0b1'000'000'000);
// *** Octal ***
std::locale::global(en_US);
test(STR("0"), STR("{:Lo}"), 00);
test(STR("1"), STR("{:Lo}"), 01);
test(STR("1,000,000,000"), STR("{:Lo}"), 01'000'000'000);
test(STR("0"), STR("{:#Lo}"), 00);
test(STR("01"), STR("{:#Lo}"), 01);
test(STR("01,000,000,000"), STR("{:#Lo}"), 01'000'000'000);
test(STR("-1"), STR("{:Lo}"), -01);
test(STR("-1,000,000,000"), STR("{:Lo}"), -01'000'000'000);
test(STR("-01"), STR("{:#Lo}"), -01);
test(STR("-01,000,000,000"), STR("{:#Lo}"), -01'000'000'000);
std::locale::global(loc);
test(STR("0"), STR("{:Lo}"), 00);
test(STR("1"), STR("{:Lo}"), 01);
test(STR("1_0_00_000_00_0"), STR("{:Lo}"), 01'000'000'000);
test(STR("0"), STR("{:#Lo}"), 00);
test(STR("01"), STR("{:#Lo}"), 01);
test(STR("01_0_00_000_00_0"), STR("{:#Lo}"), 01'000'000'000);
test(STR("-1"), STR("{:Lo}"), -01);
test(STR("-1_0_00_000_00_0"), STR("{:Lo}"), -01'000'000'000);
test(STR("-01"), STR("{:#Lo}"), -01);
test(STR("-01_0_00_000_00_0"), STR("{:#Lo}"), -01'000'000'000);
test(STR("0"), en_US, STR("{:Lo}"), 00);
test(STR("1"), en_US, STR("{:Lo}"), 01);
test(STR("1,000,000,000"), en_US, STR("{:Lo}"), 01'000'000'000);
test(STR("0"), en_US, STR("{:#Lo}"), 00);
test(STR("01"), en_US, STR("{:#Lo}"), 01);
test(STR("01,000,000,000"), en_US, STR("{:#Lo}"), 01'000'000'000);
test(STR("-1"), en_US, STR("{:Lo}"), -01);
test(STR("-1,000,000,000"), en_US, STR("{:Lo}"), -01'000'000'000);
test(STR("-01"), en_US, STR("{:#Lo}"), -01);
test(STR("-01,000,000,000"), en_US, STR("{:#Lo}"), -01'000'000'000);
std::locale::global(en_US);
test(STR("0"), loc, STR("{:Lo}"), 00);
test(STR("1"), loc, STR("{:Lo}"), 01);
test(STR("1_0_00_000_00_0"), loc, STR("{:Lo}"), 01'000'000'000);
test(STR("0"), loc, STR("{:#Lo}"), 00);
test(STR("01"), loc, STR("{:#Lo}"), 01);
test(STR("01_0_00_000_00_0"), loc, STR("{:#Lo}"), 01'000'000'000);
test(STR("-1"), loc, STR("{:Lo}"), -01);
test(STR("-1_0_00_000_00_0"), loc, STR("{:Lo}"), -01'000'000'000);
test(STR("-01"), loc, STR("{:#Lo}"), -01);
test(STR("-01_0_00_000_00_0"), loc, STR("{:#Lo}"), -01'000'000'000);
// *** Hexadecimal ***
std::locale::global(en_US);
test(STR("0"), STR("{:Lx}"), 0x0);
test(STR("1"), STR("{:Lx}"), 0x1);
test(STR("1,000,000,000"), STR("{:Lx}"), 0x1'000'000'000);
test(STR("0x0"), STR("{:#Lx}"), 0x0);
test(STR("0x1"), STR("{:#Lx}"), 0x1);
test(STR("0x1,000,000,000"), STR("{:#Lx}"), 0x1'000'000'000);
test(STR("-1"), STR("{:LX}"), -0x1);
test(STR("-1,000,000,000"), STR("{:LX}"), -0x1'000'000'000);
test(STR("-0X1"), STR("{:#LX}"), -0x1);
test(STR("-0X1,000,000,000"), STR("{:#LX}"), -0x1'000'000'000);
std::locale::global(loc);
test(STR("0"), STR("{:Lx}"), 0x0);
test(STR("1"), STR("{:Lx}"), 0x1);
test(STR("1_0_00_000_00_0"), STR("{:Lx}"), 0x1'000'000'000);
test(STR("0x0"), STR("{:#Lx}"), 0x0);
test(STR("0x1"), STR("{:#Lx}"), 0x1);
test(STR("0x1_0_00_000_00_0"), STR("{:#Lx}"), 0x1'000'000'000);
test(STR("-1"), STR("{:LX}"), -0x1);
test(STR("-1_0_00_000_00_0"), STR("{:LX}"), -0x1'000'000'000);
test(STR("-0X1"), STR("{:#LX}"), -0x1);
test(STR("-0X1_0_00_000_00_0"), STR("{:#LX}"), -0x1'000'000'000);
test(STR("0"), en_US, STR("{:Lx}"), 0x0);
test(STR("1"), en_US, STR("{:Lx}"), 0x1);
test(STR("1,000,000,000"), en_US, STR("{:Lx}"), 0x1'000'000'000);
test(STR("0x0"), en_US, STR("{:#Lx}"), 0x0);
test(STR("0x1"), en_US, STR("{:#Lx}"), 0x1);
test(STR("0x1,000,000,000"), en_US, STR("{:#Lx}"), 0x1'000'000'000);
test(STR("-1"), en_US, STR("{:LX}"), -0x1);
test(STR("-1,000,000,000"), en_US, STR("{:LX}"), -0x1'000'000'000);
test(STR("-0X1"), en_US, STR("{:#LX}"), -0x1);
test(STR("-0X1,000,000,000"), en_US, STR("{:#LX}"), -0x1'000'000'000);
std::locale::global(en_US);
test(STR("0"), loc, STR("{:Lx}"), 0x0);
test(STR("1"), loc, STR("{:Lx}"), 0x1);
test(STR("1_0_00_000_00_0"), loc, STR("{:Lx}"), 0x1'000'000'000);
test(STR("0x0"), loc, STR("{:#Lx}"), 0x0);
test(STR("0x1"), loc, STR("{:#Lx}"), 0x1);
test(STR("0x1_0_00_000_00_0"), loc, STR("{:#Lx}"), 0x1'000'000'000);
test(STR("-1"), loc, STR("{:LX}"), -0x1);
test(STR("-1_0_00_000_00_0"), loc, STR("{:LX}"), -0x1'000'000'000);
test(STR("-0X1"), loc, STR("{:#LX}"), -0x1);
test(STR("-0X1_0_00_000_00_0"), loc, STR("{:#LX}"), -0x1'000'000'000);
// *** align-fill & width ***
test(STR("4_2"), loc, STR("{:L}"), 42);
test(STR(" 4_2"), loc, STR("{:6L}"), 42);
test(STR("4_2 "), loc, STR("{:<6L}"), 42);
test(STR(" 4_2 "), loc, STR("{:^6L}"), 42);
test(STR(" 4_2"), loc, STR("{:>6L}"), 42);
test(STR("4_2***"), loc, STR("{:*<6L}"), 42);
test(STR("*4_2**"), loc, STR("{:*^6L}"), 42);
test(STR("***4_2"), loc, STR("{:*>6L}"), 42);
test(STR("4_a*****"), loc, STR("{:*<8Lx}"), 0x4a);
test(STR("**4_a***"), loc, STR("{:*^8Lx}"), 0x4a);
test(STR("*****4_a"), loc, STR("{:*>8Lx}"), 0x4a);
test(STR("0x4_a***"), loc, STR("{:*<#8Lx}"), 0x4a);
test(STR("*0x4_a**"), loc, STR("{:*^#8Lx}"), 0x4a);
test(STR("***0x4_a"), loc, STR("{:*>#8Lx}"), 0x4a);
test(STR("4_A*****"), loc, STR("{:*<8LX}"), 0x4a);
test(STR("**4_A***"), loc, STR("{:*^8LX}"), 0x4a);
test(STR("*****4_A"), loc, STR("{:*>8LX}"), 0x4a);
test(STR("0X4_A***"), loc, STR("{:*<#8LX}"), 0x4a);
test(STR("*0X4_A**"), loc, STR("{:*^#8LX}"), 0x4a);
test(STR("***0X4_A"), loc, STR("{:*>#8LX}"), 0x4a);
// Test whether zero padding is ignored
test(STR("4_2 "), loc, STR("{:<06L}"), 42);
test(STR(" 4_2 "), loc, STR("{:^06L}"), 42);
test(STR(" 4_2"), loc, STR("{:>06L}"), 42);
// *** zero-padding & width ***
test(STR(" 4_2"), loc, STR("{:6L}"), 42);
test(STR("0004_2"), loc, STR("{:06L}"), 42);
test(STR("-004_2"), loc, STR("{:06L}"), -42);
test(STR("000004_a"), loc, STR("{:08Lx}"), 0x4a);
test(STR("0x0004_a"), loc, STR("{:#08Lx}"), 0x4a);
test(STR("0X0004_A"), loc, STR("{:#08LX}"), 0x4a);
test(STR("-00004_a"), loc, STR("{:08Lx}"), -0x4a);
test(STR("-0x004_a"), loc, STR("{:#08Lx}"), -0x4a);
test(STR("-0X004_A"), loc, STR("{:#08LX}"), -0x4a);
}
template <class CharT>
void test() {
test_integer<CharT>();
}
int main(int, char**) {
test<char>();
test<wchar_t>();
return 0;
}

libcxx/test/std/utilities/format/format.functions/tests.inc

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Contains the test cases for the format functions without locale. // Contains the test cases for the format functions. The locale-specific form
// aren't tested in these test cases. They're tested in
// locale-specific_form.pass.cpp.
#define STR(S) MAKE_STRING(CharT, S) #define STR(S) MAKE_STRING(CharT, S)
template <class CharT> template <class CharT>
std::vector<std::basic_string<CharT>> invalid_types(std::string valid) { std::vector<std::basic_string<CharT>> invalid_types(std::string valid) {
std::vector<std::basic_string<CharT>> result; std::vector<std::basic_string<CharT>> result;
#define CASE(T) \ #define CASE(T) \
▲ Show 20 Lines • Show All 225 Lines • ▼ Show 20 Linesvoid test_string() {
test_string<CharT>(const_cast<CharT*>(world.c_str()), test_string<CharT>(const_cast<CharT*>(world.c_str()),
const_cast<CharT*>(universe.c_str())); const_cast<CharT*>(universe.c_str()));
test_string<CharT>(std::basic_string_view<CharT>(world), test_string<CharT>(std::basic_string_view<CharT>(world),
std::basic_string_view<CharT>(universe)); std::basic_string_view<CharT>(universe));
test_string<CharT>(world, universe); test_string<CharT>(world, universe);
test_string_unicode<CharT>(); test_string_unicode<CharT>();
} }
template <class I, class CharT>
void test_integer_as_integer() {
// *** align-fill & width ***
test(STR("answer is '42'"), STR("answer is '{:<1}'"), I(42));
test(STR("answer is '42'"), STR("answer is '{:<2}'"), I(42));
test(STR("answer is '42 '"), STR("answer is '{:<3}'"), I(42));
test(STR("answer is ' 42'"), STR("answer is '{:7}'"), I(42));
test(STR("answer is ' 42'"), STR("answer is '{:>7}'"), I(42));
test(STR("answer is '42 '"), STR("answer is '{:<7}'"), I(42));
test(STR("answer is ' 42 '"), STR("answer is '{:^7}'"), I(42));
test(STR("answer is '*****42'"), STR("answer is '{:*>7}'"), I(42));
test(STR("answer is '42*****'"), STR("answer is '{:*<7}'"), I(42));
test(STR("answer is '**42***'"), STR("answer is '{:*^7}'"), I(42));
// Test whether zero padding is ignored
test(STR("answer is ' 42'"), STR("answer is '{:>07}'"), I(42));
test(STR("answer is '42 '"), STR("answer is '{:<07}'"), I(42));
test(STR("answer is ' 42 '"), STR("answer is '{:^07}'"), I(42));
// *** Sign ***
if constexpr (std::signed_integral<I>)
test(STR("answer is -42"), STR("answer is {}"), I(-42));
test(STR("answer is 0"), STR("answer is {}"), I(0));
test(STR("answer is 42"), STR("answer is {}"), I(42));
if constexpr (std::signed_integral<I>)
test(STR("answer is -42"), STR("answer is {:-}"), I(-42));
test(STR("answer is 0"), STR("answer is {:-}"), I(0));
test(STR("answer is 42"), STR("answer is {:-}"), I(42));
if constexpr (std::signed_integral<I>)
test(STR("answer is -42"), STR("answer is {:+}"), I(-42));
test(STR("answer is +0"), STR("answer is {:+}"), I(0));
test(STR("answer is +42"), STR("answer is {:+}"), I(42));
if constexpr (std::signed_integral<I>)
test(STR("answer is -42"), STR("answer is {: }"), I(-42));
test(STR("answer is 0"), STR("answer is {: }"), I(0));
test(STR("answer is 42"), STR("answer is {: }"), I(42));
// *** alternate form ***
if constexpr (std::signed_integral<I>) {
test(STR("answer is -42"), STR("answer is {:#}"), I(-42));
test(STR("answer is -42"), STR("answer is {:#d}"), I(-42));
test(STR("answer is -101010"), STR("answer is {:b}"), I(-42));
test(STR("answer is -0b101010"), STR("answer is {:#b}"), I(-42));
test(STR("answer is -0B101010"), STR("answer is {:#B}"), I(-42));
test(STR("answer is -52"), STR("answer is {:o}"), I(-42));
test(STR("answer is -052"), STR("answer is {:#o}"), I(-42));
test(STR("answer is -2a"), STR("answer is {:x}"), I(-42));
test(STR("answer is -0x2a"), STR("answer is {:#x}"), I(-42));
test(STR("answer is -2A"), STR("answer is {:X}"), I(-42));
test(STR("answer is -0X2A"), STR("answer is {:#X}"), I(-42));
}
test(STR("answer is 0"), STR("answer is {:#}"), I(0));
test(STR("answer is 0"), STR("answer is {:#d}"), I(0));
test(STR("answer is 0"), STR("answer is {:b}"), I(0));
test(STR("answer is 0b0"), STR("answer is {:#b}"), I(0));
test(STR("answer is 0B0"), STR("answer is {:#B}"), I(0));
test(STR("answer is 0"), STR("answer is {:o}"), I(0));
test(STR("answer is 0"), STR("answer is {:#o}"), I(0));
test(STR("answer is 0"), STR("answer is {:x}"), I(0));
test(STR("answer is 0x0"), STR("answer is {:#x}"), I(0));
test(STR("answer is 0"), STR("answer is {:X}"), I(0));
test(STR("answer is 0X0"), STR("answer is {:#X}"), I(0));
test(STR("answer is +42"), STR("answer is {:+#}"), I(42));
test(STR("answer is +42"), STR("answer is {:+#d}"), I(42));
test(STR("answer is +101010"), STR("answer is {:+b}"), I(42));
test(STR("answer is +0b101010"), STR("answer is {:+#b}"), I(42));
test(STR("answer is +0B101010"), STR("answer is {:+#B}"), I(42));
test(STR("answer is +52"), STR("answer is {:+o}"), I(42));
test(STR("answer is +052"), STR("answer is {:+#o}"), I(42));
test(STR("answer is +2a"), STR("answer is {:+x}"), I(42));
test(STR("answer is +0x2a"), STR("answer is {:+#x}"), I(42));
test(STR("answer is +2A"), STR("answer is {:+X}"), I(42));
test(STR("answer is +0X2A"), STR("answer is {:+#X}"), I(42));
// *** zero-padding & width ***
if constexpr (std::signed_integral<I>) {
test(STR("answer is -00000000042"), STR("answer is {:#012}"), I(-42));
test(STR("answer is -00000000042"), STR("answer is {:#012d}"), I(-42));
test(STR("answer is -00000101010"), STR("answer is {:012b}"), I(-42));
test(STR("answer is -0b000101010"), STR("answer is {:#012b}"), I(-42));
test(STR("answer is -0B000101010"), STR("answer is {:#012B}"), I(-42));
test(STR("answer is -00000000052"), STR("answer is {:012o}"), I(-42));
test(STR("answer is -00000000052"), STR("answer is {:#012o}"), I(-42));
test(STR("answer is -0000000002a"), STR("answer is {:012x}"), I(-42));
test(STR("answer is -0x00000002a"), STR("answer is {:#012x}"), I(-42));
test(STR("answer is -0000000002A"), STR("answer is {:012X}"), I(-42));
test(STR("answer is -0X00000002A"), STR("answer is {:#012X}"), I(-42));
}
test(STR("answer is 000000000000"), STR("answer is {:#012}"), I(0));
test(STR("answer is 000000000000"), STR("answer is {:#012d}"), I(0));
test(STR("answer is 000000000000"), STR("answer is {:012b}"), I(0));
test(STR("answer is 0b0000000000"), STR("answer is {:#012b}"), I(0));
test(STR("answer is 0B0000000000"), STR("answer is {:#012B}"), I(0));
test(STR("answer is 000000000000"), STR("answer is {:012o}"), I(0));
test(STR("answer is 000000000000"), STR("answer is {:#012o}"), I(0));
test(STR("answer is 000000000000"), STR("answer is {:012x}"), I(0));
test(STR("answer is 0x0000000000"), STR("answer is {:#012x}"), I(0));
test(STR("answer is 000000000000"), STR("answer is {:012X}"), I(0));
test(STR("answer is 0X0000000000"), STR("answer is {:#012X}"), I(0));
test(STR("answer is +00000000042"), STR("answer is {:+#012}"), I(42));
test(STR("answer is +00000000042"), STR("answer is {:+#012d}"), I(42));
test(STR("answer is +00000101010"), STR("answer is {:+012b}"), I(42));
test(STR("answer is +0b000101010"), STR("answer is {:+#012b}"), I(42));
test(STR("answer is +0B000101010"), STR("answer is {:+#012B}"), I(42));
test(STR("answer is +00000000052"), STR("answer is {:+012o}"), I(42));
test(STR("answer is +00000000052"), STR("answer is {:+#012o}"), I(42));
test(STR("answer is +0000000002a"), STR("answer is {:+012x}"), I(42));
test(STR("answer is +0x00000002a"), STR("answer is {:+#012x}"), I(42));
test(STR("answer is +0000000002A"), STR("answer is {:+012X}"), I(42));
test(STR("answer is +0X00000002A"), STR("answer is {:+#012X}"), I(42));
// *** precision ***
test_exception("A precision field isn't allowed in this format-spec",
STR("{:.}"), I(0));
test_exception("A precision field isn't allowed in this format-spec",
STR("{:.0}"), I(0));
test_exception("A precision field isn't allowed in this format-spec",
STR("{:.42}"), I(0));
// *** locale-specific form ***
// See locale-specific_form.pass.cpp
// *** type ***
for (const auto& fmt : invalid_types<CharT>("bBcdoxX"))
test_exception(
"The format-spec type has a type not supported for an integer argument",
fmt, 42);
}
template <class I, class CharT>
void test_integer_as_char() {
// *** align-fill & width ***
// TODO FMT Validate whether this should be left aligned
test(STR("answer is ' *'"), STR("answer is '{:6c}'"), I(42));
vitautUnsubmitted
Done
ReplyInline Actions

Per my earlier comment this should indeed be left-aligned.

vitaut: Per my earlier comment this should indeed be left-aligned.
MordanteAuthorUnsubmitted
Done
ReplyInline Actions

I assumed that was intended. However my interpretation of the wording requires it to be right aligned:
This is the default for arithmetic types other than charT and bool or when an integer presentation type is specified.
My interpretation is that the supplied type in an aritmetic type, so this rule applies.
Do you agree with my interpretation?

I agree it's silly that the result of format("{:6c}", 42); differs from the result of format("{:6}", '*');. So I'll adjust it.

Mordante: I assumed that was intended. However my interpretation of the wording requires it to be right…
vitautUnsubmitted
Not Done
ReplyInline Actions

Yeah, I think P1652 missed this part of the wording. The interpretation depends on whether you look at the original types or types after conversion per presentation specifiers. I suggest opening an LWG issue to clarify that we want the latter.

vitaut: Yeah, I think P1652 missed this part of the wording. The interpretation depends on whether you…
test(STR("answer is ' *'"), STR("answer is '{:>6c}'"), I(42));
test(STR("answer is '* '"), STR("answer is '{:<6c}'"), I(42));
test(STR("answer is ' * '"), STR("answer is '{:^6c}'"), I(42));
test(STR("answer is '-----*'"), STR("answer is '{:->6c}'"), I(42));
test(STR("answer is '*-----'"), STR("answer is '{:-<6c}'"), I(42));
test(STR("answer is '--*---'"), STR("answer is '{:-^6c}'"), I(42));
// Test whether zero padding is ignored
test(STR("answer is ' *'"), STR("answer is '{:>06c}'"), I(42));
test(STR("answer is '* '"), STR("answer is '{:<06c}'"), I(42));
test(STR("answer is ' * '"), STR("answer is '{:^06c}'"), I(42));
// *** Sign ***
test(STR("answer is *"), STR("answer is {:c}"), I(42));
test(STR("answer is *"), STR("answer is {:-c}"), I(42));
test(STR("answer is *"), STR("answer is {:+c}"), I(42));
test(STR("answer is *"), STR("answer is {: c}"), I(42));
// *** alternate form ***
test(STR("answer is *"), STR("answer is {:#c}"), I(42));
test(STR("answer is *"), STR("answer is {:-#c}"), I(42));
test(STR("answer is *"), STR("answer is {:+#c}"), I(42));
test(STR("answer is *"), STR("answer is {: #c}"), I(42));
// *** zero-padding & width ***
test(STR("answer is ' *'"), STR("answer is '{:+#012c}'"), I(42));
// *** precision ***
test_exception("A precision field isn't allowed in this format-spec",
STR("{:.c}"), I(0));
test_exception("A precision field isn't allowed in this format-spec",
STR("{:.0c}"), I(0));
test_exception("A precision field isn't allowed in this format-spec",
STR("{:.42c}"), I(0));
// *** locale-specific form ***
// Note it has no effect but it's allowed.
test(STR("answer is '*'"), STR("answer is '{:Lc}'"), I(42));
// *** type ***
for (const auto& fmt : invalid_types<CharT>("bBcdoxX"))
test_exception(
"The format-spec type has a type not supported for an integer argument",
fmt, I(42));
// *** Validate range ***
// TODO FMT Update test after adding 128-bit support.
if constexpr (sizeof(I) <= sizeof(long long)) {
// The code has some duplications to keep the if statement readable.
if constexpr (std::signed_integral<CharT>) {
if constexpr (std::signed_integral<I> && sizeof(I) > sizeof(CharT)) {
test_exception("Integral value outside the range of the char type",
STR("{:c}"), std::numeric_limits<I>::min());
test_exception("Integral value outside the range of the char type",
STR("{:c}"), std::numeric_limits<I>::max());
} else if constexpr (std::unsigned_integral<I> &&
sizeof(I) >= sizeof(CharT)) {
test_exception("Integral value outside the range of the char type",
STR("{:c}"), std::numeric_limits<I>::max());
}
} else if constexpr (sizeof(I) > sizeof(CharT)) {
test_exception("Integral value outside the range of the char type",
STR("{:c}"), std::numeric_limits<I>::max());
}
}
}
template <class I, class CharT>
void test_integer() {
test_integer_as_integer<I, CharT>();
test_integer_as_char<I, CharT>();
}
template <class CharT>
void test_signed_integer() {
test_integer<signed char, CharT>();
test_integer<short, CharT>();
test_integer<int, CharT>();
test_integer<long, CharT>();
test_integer<long long, CharT>();
#ifndef _LIBCPP_HAS_NO_INT128
test_integer<__int128_t, CharT>();
#endif
// *** test the minma and maxima ***
test(STR("-0b10000000"), STR("{:#b}"), std::numeric_limits<int8_t>::min());
test(STR("-0200"), STR("{:#o}"), std::numeric_limits<int8_t>::min());
test(STR("-128"), STR("{:#}"), std::numeric_limits<int8_t>::min());
test(STR("-0x80"), STR("{:#x}"), std::numeric_limits<int8_t>::min());
test(STR("-0b1000000000000000"), STR("{:#b}"),
std::numeric_limits<int16_t>::min());
test(STR("-0100000"), STR("{:#o}"), std::numeric_limits<int16_t>::min());
test(STR("-32768"), STR("{:#}"), std::numeric_limits<int16_t>::min());
test(STR("-0x8000"), STR("{:#x}"), std::numeric_limits<int16_t>::min());
test(STR("-0b10000000000000000000000000000000"), STR("{:#b}"),
std::numeric_limits<int32_t>::min());
test(STR("-020000000000"), STR("{:#o}"), std::numeric_limits<int32_t>::min());
test(STR("-2147483648"), STR("{:#}"), std::numeric_limits<int32_t>::min());
test(STR("-0x80000000"), STR("{:#x}"), std::numeric_limits<int32_t>::min());
test(STR("-0b100000000000000000000000000000000000000000000000000000000000000"
"0"),
STR("{:#b}"), std::numeric_limits<int64_t>::min());
test(STR("-01000000000000000000000"), STR("{:#o}"),
std::numeric_limits<int64_t>::min());
test(STR("-9223372036854775808"), STR("{:#}"),
std::numeric_limits<int64_t>::min());
test(STR("-0x8000000000000000"), STR("{:#x}"),
std::numeric_limits<int64_t>::min());
test(STR("0b1111111"), STR("{:#b}"), std::numeric_limits<int8_t>::max());
test(STR("0177"), STR("{:#o}"), std::numeric_limits<int8_t>::max());
test(STR("127"), STR("{:#}"), std::numeric_limits<int8_t>::max());
test(STR("0x7f"), STR("{:#x}"), std::numeric_limits<int8_t>::max());
test(STR("0b111111111111111"), STR("{:#b}"),
std::numeric_limits<int16_t>::max());
test(STR("077777"), STR("{:#o}"), std::numeric_limits<int16_t>::max());
test(STR("32767"), STR("{:#}"), std::numeric_limits<int16_t>::max());
test(STR("0x7fff"), STR("{:#x}"), std::numeric_limits<int16_t>::max());
test(STR("0b1111111111111111111111111111111"), STR("{:#b}"),
std::numeric_limits<int32_t>::max());
test(STR("017777777777"), STR("{:#o}"), std::numeric_limits<int32_t>::max());
test(STR("2147483647"), STR("{:#}"), std::numeric_limits<int32_t>::max());
test(STR("0x7fffffff"), STR("{:#x}"), std::numeric_limits<int32_t>::max());
test(STR("0b111111111111111111111111111111111111111111111111111111111111111"),
STR("{:#b}"), std::numeric_limits<int64_t>::max());
test(STR("0777777777777777777777"), STR("{:#o}"),
std::numeric_limits<int64_t>::max());
test(STR("9223372036854775807"), STR("{:#}"),
std::numeric_limits<int64_t>::max());
test(STR("0x7fffffffffffffff"), STR("{:#x}"),
std::numeric_limits<int64_t>::max());
// TODO FMT Add __int128_t test after implementing full range.
}
template <class CharT>
void test_unsigned_integer() {
test_integer<unsigned char, CharT>();
test_integer<unsigned short, CharT>();
test_integer<unsigned, CharT>();
test_integer<unsigned long, CharT>();
test_integer<unsigned long long, CharT>();
#ifndef _LIBCPP_HAS_NO_INT128
test_integer<__uint128_t, CharT>();
#endif
// *** test the maxima ***
test(STR("0b11111111"), STR("{:#b}"), std::numeric_limits<uint8_t>::max());
test(STR("0377"), STR("{:#o}"), std::numeric_limits<uint8_t>::max());
test(STR("255"), STR("{:#}"), std::numeric_limits<uint8_t>::max());
test(STR("0xff"), STR("{:#x}"), std::numeric_limits<uint8_t>::max());
test(STR("0b1111111111111111"), STR("{:#b}"),
std::numeric_limits<uint16_t>::max());
test(STR("0177777"), STR("{:#o}"), std::numeric_limits<uint16_t>::max());
test(STR("65535"), STR("{:#}"), std::numeric_limits<uint16_t>::max());
test(STR("0xffff"), STR("{:#x}"), std::numeric_limits<uint16_t>::max());
test(STR("0b11111111111111111111111111111111"), STR("{:#b}"),
std::numeric_limits<uint32_t>::max());
test(STR("037777777777"), STR("{:#o}"), std::numeric_limits<uint32_t>::max());
test(STR("4294967295"), STR("{:#}"), std::numeric_limits<uint32_t>::max());
test(STR("0xffffffff"), STR("{:#x}"), std::numeric_limits<uint32_t>::max());
test(
STR("0b1111111111111111111111111111111111111111111111111111111111111111"),
STR("{:#b}"), std::numeric_limits<uint64_t>::max());
test(STR("01777777777777777777777"), STR("{:#o}"),
std::numeric_limits<uint64_t>::max());
test(STR("18446744073709551615"), STR("{:#}"),
std::numeric_limits<uint64_t>::max());
test(STR("0xffffffffffffffff"), STR("{:#x}"),
std::numeric_limits<uint64_t>::max());
// TODO FMT Add __uint128_t test after implementing full range.
}
template <class CharT> template <class CharT>
void test() { void test() {
// *** Test escaping *** // *** Test escaping ***
test(STR("{"), STR("{{")); test(STR("{"), STR("{{"));
test(STR("}"), STR("}}")); test(STR("}"), STR("}}"));
// *** Test argument ID *** // *** Test argument ID ***
test(STR("hello 01"), STR("hello {0:}{1:}"), false, true); test(STR("hello 01"), STR("hello {0:}{1:}"), false, true);
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines test(STR("hello 42"), STR("hello {}"), static_cast<__int128_t>(42));
test_exception( test_exception(
"128 bit value is outside of implemented range", STR("{}"), "128 bit value is outside of implemented range", STR("{}"),
static_cast<__int128_t>(std::numeric_limits<long long>::min()) - 1); static_cast<__int128_t>(std::numeric_limits<long long>::min()) - 1);
test_exception( test_exception(
"128 bit value is outside of implemented range", STR("{}"), "128 bit value is outside of implemented range", STR("{}"),
static_cast<__int128_t>(std::numeric_limits<long long>::max()) + 1); static_cast<__int128_t>(std::numeric_limits<long long>::max()) + 1);
} }
#endif #endif
test_signed_integer<CharT>();
// ** Test unsigned integral format argument *** // ** Test unsigned integral format argument ***
test(STR("hello 42"), STR("hello {}"), static_cast<unsigned char>(42)); test(STR("hello 42"), STR("hello {}"), static_cast<unsigned char>(42));
test(STR("hello 42"), STR("hello {}"), static_cast<unsigned short>(42)); test(STR("hello 42"), STR("hello {}"), static_cast<unsigned short>(42));
test(STR("hello 42"), STR("hello {}"), static_cast<unsigned>(42)); test(STR("hello 42"), STR("hello {}"), static_cast<unsigned>(42));
test(STR("hello 42"), STR("hello {}"), static_cast<unsigned long>(42)); test(STR("hello 42"), STR("hello {}"), static_cast<unsigned long>(42));
test(STR("hello 42"), STR("hello {}"), static_cast<unsigned long long>(42)); test(STR("hello 42"), STR("hello {}"), static_cast<unsigned long long>(42));
#ifndef _LIBCPP_HAS_NO_INT128 #ifndef _LIBCPP_HAS_NO_INT128
test(STR("hello 42"), STR("hello {}"), static_cast<__uint128_t>(42)); test(STR("hello 42"), STR("hello {}"), static_cast<__uint128_t>(42));
{ {
// Note 128 bit support is only partly implemented test the range // Note 128 bit support is only partly implemented test the range
// conditions here. // conditions here.
std::basic_string<CharT> max = std::basic_string<CharT> max =
std::format(STR("{}"), std::numeric_limits<unsigned long long>::max()); std::format(STR("{}"), std::numeric_limits<unsigned long long>::max());
test(max, STR("{}"), test(max, STR("{}"),
static_cast<__uint128_t>( static_cast<__uint128_t>(
std::numeric_limits<unsigned long long>::max())); std::numeric_limits<unsigned long long>::max()));
test_exception("128 bit value is outside of implemented range", STR("{}"), test_exception("128 bit value is outside of implemented range", STR("{}"),
static_cast<__uint128_t>( static_cast<__uint128_t>(
std::numeric_limits<unsigned long long>::max()) + std::numeric_limits<unsigned long long>::max()) +
1); 1);
} }
#endif #endif
test_unsigned_integer<CharT>();
// *** Test floating point format argument *** // *** Test floating point format argument ***
test(STR("hello 42.000000"), STR("hello {}"), static_cast<float>(42)); test(STR("hello 42.000000"), STR("hello {}"), static_cast<float>(42));
test(STR("hello 42.000000"), STR("hello {}"), static_cast<double>(42)); test(STR("hello 42.000000"), STR("hello {}"), static_cast<double>(42));
test(STR("hello 42.000000"), STR("hello {}"), static_cast<long double>(42)); test(STR("hello 42.000000"), STR("hello {}"), static_cast<long double>(42));
} }
int main(int, char**) { int main(int, char**) {
test_char_to_wchar(); test_char_to_wchar();
test<char>(); test<char>();
test<wchar_t>(); test<wchar_t>();
return 0; return 0;
} }

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

  • This file was added.
//===----------------------------------------------------------------------===//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LIBCXX_TEST_STD_UTILITIES_FORMAT_FORMAT_STRING_FORMAT_STRING_STD_CONCEPTS_PRECISION_H
#define LIBCXX_TEST_STD_UTILITIES_FORMAT_FORMAT_STRING_FORMAT_STRING_STD_CONCEPTS_PRECISION_H
template <class T>
concept has_precision = requires(T parser) {
parser.__precision;
};
template <class T>
concept has_precision_as_arg = requires(T parser) {
parser.__precision_as_arg;
};
#endif // LIBCXX_TEST_STD_UTILITIES_FORMAT_FORMAT_STRING_FORMAT_STRING_STD_CONCEPTS_PRECISION_H

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

  • This file was added.
//===----------------------------------------------------------------------===//
// 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
// <format>
// Tests the parsing of the format string as specified in [format.string.std].
// It validates whether the std-format-spec is valid for a string type.
#include <format>
#include <cassert>
#ifndef _LIBCPP_HAS_NO_LOCALIZATION
#include <iostream>
#endif
#include "concepts_precision.h"
#include "test_macros.h"
#include "make_string.h"
#define CSTR(S) MAKE_CSTRING(CharT, S)
using namespace std::__format_spec;
template <class CharT>
using parser = __parser_integer<CharT>;
#include "test_exception.h" // requires parser
template <class CharT>
struct Expected {
CharT fill;
_Flags::_Alignment alignment;
_Flags::_Sign sign;
bool alternate_form;
bool zero_padding;
uint32_t width;
bool width_as_arg;
bool locale_specific_form;
_Flags::_Type type;
};
template <class CharT>
constexpr void test(Expected<CharT> expected, size_t size,
std::basic_string_view<CharT> fmt) {
// Initialize parser with sufficient arguments to avoid the parsing to fail
// due to insufficient arguments.
std::basic_format_parse_context<CharT> parse_ctx(fmt,
std::__format::__number_max);
auto begin = parse_ctx.begin();
auto end = parse_ctx.end();
parser<CharT> parser;
auto it = parser.parse(parse_ctx);
assert(begin == parse_ctx.begin());
assert(end == parse_ctx.end());
assert(begin + size == it);
assert(parser.__fill == expected.fill);
assert(parser.__alignment == expected.alignment);
assert(parser.__sign == expected.sign);
assert(parser.__alternate_form == expected.alternate_form);
assert(parser.__zero_padding == expected.zero_padding);
assert(parser.__width == expected.width);
assert(parser.__width_as_arg == expected.width_as_arg);
assert(parser.__locale_specific_form == expected.locale_specific_form);
assert(parser.__type == expected.type);
}
template <class CharT>
constexpr void test(Expected<CharT> expected, size_t size, const CharT* f) {
// The format-spec is valid if completely consumed or terminates at a '}'.
// The valid inputs all end with a '}'. The test is executed twice:
// - first with the terminating '}',
// - second consuming the entire input.
std::basic_string_view<CharT> fmt{f};
assert(fmt.back() == CharT('}') && "Pre-condition failure");
test(expected, size, fmt);
fmt.remove_suffix(1);
test(expected, size, fmt);
}
template <class CharT>
constexpr void test() {
parser<CharT> parser;
assert(parser.__fill == CharT(' '));
assert(parser.__alignment == _Flags::_Alignment::__default);
assert(parser.__sign == _Flags::_Sign::__default);
assert(parser.__alternate_form == false);
assert(parser.__zero_padding == false);
assert(parser.__width == 0);
assert(parser.__width_as_arg == false);
static_assert(!has_precision<decltype(parser)>);
static_assert(!has_precision_as_arg<decltype(parser)>);
assert(parser.__locale_specific_form == false);
assert(parser.__type == _Flags::_Type::__default);
// *** Align-fill ***
test({CharT(' '), _Flags::_Alignment::__right, _Flags::_Sign::__default,
false, false, 0, false, false, _Flags::_Type::__decimal},
0, CSTR("}"));
test({CharT(' '), _Flags::_Alignment::__center, _Flags::_Sign::__default,
false, false, 0, false, false, _Flags::_Type::__decimal},
1, CSTR("^}"));
test({CharT('-'), _Flags::_Alignment::__left, _Flags::_Sign::__default, false,
false, 0, false, false, _Flags::_Type::__decimal},
2, CSTR("-<}"));
test({CharT('+'), _Flags::_Alignment::__left, _Flags::_Sign::__default, false,
false, 0, false, false, _Flags::_Type::__decimal},
2, CSTR("+<}"));
// *** Sign ***
test({CharT(' '), _Flags::_Alignment::__right, _Flags::_Sign::__minus, false,
false, 0, false, false, _Flags::_Type::__decimal},
1, CSTR("-}"));
test({CharT(' '), _Flags::_Alignment::__right, _Flags::_Sign::__plus, false,
false, 0, false, false, _Flags::_Type::__decimal},
1, CSTR("+}"));
test({CharT(' '), _Flags::_Alignment::__right, _Flags::_Sign::__space, false,
false, 0, false, false, _Flags::_Type::__decimal},
1, CSTR(" }"));
// *** Alternate form ***
// TODO FMT The standard seems to indicate right alignment.
test({CharT(' '), _Flags::_Alignment::__right, _Flags::_Sign::__default, true,
false, 0, false, false, _Flags::_Type::__decimal},
1, CSTR("#}"));
test({CharT(' '), _Flags::_Alignment::__right, _Flags::_Sign::__default, true,
false, 0, false, false, _Flags::_Type::__decimal},
2, CSTR("#d}"));
test({CharT(' '), _Flags::_Alignment::__right, _Flags::_Sign::__default, true,
false, 0, false, false, _Flags::_Type::__char},
2, CSTR("#c}"));
// *** Zero padding ***
// TODO FMT What to do with zero-padding without a width?
// [format.string.std]/13
// A zero (0) character preceding the width field pads the field with
// leading zeros (following any indication of sign or base) to the field
// width, except when applied to an infinity or NaN.
// Obviously it makes no sense, but should it be allowed or is it a format
// errror?
test({CharT(' '), _Flags::_Alignment::__default, _Flags::_Sign::__default,
false, true, 0, false, false, _Flags::_Type::__decimal},
1, CSTR("0}"));
test({CharT(' '), _Flags::_Alignment::__center, _Flags::_Sign::__default,
false, false, 0, false, false, _Flags::_Type::__decimal},
2, CSTR("^0}"));
// *** Width ***
test({CharT(' '), _Flags::_Alignment::__right, _Flags::_Sign::__default,
false, false, 1, false, false, _Flags::_Type::__decimal},
1, CSTR("1}"));
test({CharT(' '), _Flags::_Alignment::__right, _Flags::_Sign::__default,
false, false, 42, false, false, _Flags::_Type::__decimal},
2, CSTR("42}"));
static_assert(std::__format::__number_max == 2'147'483'647,
"Update the assert and the test.");
test({CharT(' '), _Flags::_Alignment::__right, _Flags::_Sign::__default,
false, false, 2'147'483'647, false, false, _Flags::_Type::__decimal},
10, CSTR("2147483647}"));
// *** Precision ***
test_exception("A precision field isn't allowed in this format-spec",
CSTR("."));
test_exception("A precision field isn't allowed in this format-spec",
CSTR(".1"));
// *** Locale-specific form ***
test({CharT(' '), _Flags::_Alignment::__right, _Flags::_Sign::__default,
false, false, 0, false, true, _Flags::_Type::__decimal},
1, CSTR("L}"));
test({CharT(' '), _Flags::_Alignment::__right, _Flags::_Sign::__default,
false, false, 0, false, true, _Flags::_Type::__decimal},
2, CSTR("Ld}"));
test({CharT(' '), _Flags::_Alignment::__right, _Flags::_Sign::__default,
false, false, 0, false, true, _Flags::_Type::__char},
2, CSTR("Lc}"));
// *** Type ***
{
const char* expected =
"The format-spec type has a type not supported for an integer argument";
test_exception(expected, CSTR("A}"));
test_exception(expected, CSTR("E}"));
test_exception(expected, CSTR("F}"));
test_exception(expected, CSTR("G}"));
test_exception(expected, CSTR("a}"));
test_exception(expected, CSTR("e}"));
test_exception(expected, CSTR("f}"));
test_exception(expected, CSTR("g}"));
test_exception(expected, CSTR("p}"));
test_exception(expected, CSTR("s}"));
}
// **** General ***
test_exception("The format-spec should consume the input or end with a '}'",
CSTR("ss"));
}
constexpr bool test() {
test<char>();
test<wchar_t>();
#ifndef _LIBCPP_HAS_NO_CHAR8_T
test<char8_t>();
#endif
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
test<char16_t>();
test<char32_t>();
#endif
return true;
}
int main(int, char**) {
#ifndef _WIN32
// Make sure the parsers match the expectations. The layout of the
// subobjects is chosen to minimize the size required.
static_assert(sizeof(parser<char>) == 2 * sizeof(uint32_t));
static_assert(
sizeof(parser<wchar_t>) ==
(sizeof(wchar_t) <= 2 ? 2 * sizeof(uint32_t) : 3 * sizeof(uint32_t)));
#ifndef _LIBCPP_HAS_NO_CHAR8_T
static_assert(sizeof(parser<char8_t>) == 2 * sizeof(uint32_t));
#endif
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
static_assert(sizeof(parser<char16_t>) == 2 * sizeof(uint32_t));
static_assert(sizeof(parser<char32_t>) == 3 * sizeof(uint32_t));
#endif
#endif
test();
static_assert(test());
return 0;
}