[libc++][format] Fixes floating-point formatting.

[Mordante]

Summary

Formatting the alternate form for the general categories should keep the
trailing zeros. This was reported by @fsb4000 in D131336.

The default format uses general formatting but this should not keep the
trailing zeros so the default format is not passed to the formatter.

While testing I found an off by one error; finding the exponent character
e in 1e+03 will start at after the 1 so a size of 4 can contain an
exponent.

[Mordante]

Removes Unicode to fix CI.

[Mordante]

Adds a missing include.

[fsb4000]

LGTM but I am not a format expert.

libcxx/include/__format/formatter_floating_point.h

 // -*- 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_FLOATING_POINT_H
 #define _LIBCPP___FORMAT_FORMATTER_FLOATING_POINT_H
 
 #include <__algorithm/copy_n.h>
 #include <__algorithm/find.h>
+#include <__algorithm/max.h>
 #include <__algorithm/min.h>
 #include <__algorithm/rotate.h>
 #include <__algorithm/transform.h>
 #include <__concepts/arithmetic.h>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__format/concepts.h>
 #include <__format/format_parse_context.h>
public:
   _LIBCPP_HIDE_FROM_ABI __float_buffer& operator=(const __float_buffer&) = delete;
 
   _LIBCPP_HIDE_FROM_ABI char* begin() const { return __begin_; }
   _LIBCPP_HIDE_FROM_ABI char* end() const { return __begin_ + __size_; }
 
   _LIBCPP_HIDE_FROM_ABI int __precision() const { return __precision_; }
   _LIBCPP_HIDE_FROM_ABI int __num_trailing_zeros() const { return __num_trailing_zeros_; }
   _LIBCPP_HIDE_FROM_ABI void __remove_trailing_zeros() { __num_trailing_zeros_ = 0; }
+  _LIBCPP_HIDE_FROM_ABI void __add_trailing_zeros(int __zeros) { __num_trailing_zeros_ += __zeros; }
 
 private:
   int __precision_;
   int __num_trailing_zeros_{0};
   size_t __size_;
   char* __begin_;
   char __buffer_[_Traits::__stack_buffer_size];
 };

 /// Finds the position of the exponent character 'e' at the end of the buffer.
 ///
 /// Assuming there is an exponent the input will terminate with
 /// eSdd and eSdddd (S = sign, d = digit)
 ///
 /// \returns a pointer to the exponent or __last when not found.
 constexpr inline _LIBCPP_HIDE_FROM_ABI char* __find_exponent(char* __first, char* __last) {
   ptrdiff_t __size = __last - __first;
-  if (__size > 4) {
+  if (__size >= 4) {
     __first = __last - _VSTD::min(__size, ptrdiff_t(6));
     for (; __first != __last - 3; ++__first) {
       if (*__first == 'e')
         return __first;
     }
   }
   return __last;
 }
if (__first == __result.__last) {
     if (__result.__exponent != __result.__last)
       // In scientific mode if there's a radix point it will always be after
       // the first digit. (This is the position __first points at).
       __result.__radix_point = *__first == '.' ? __first : __result.__last;
     else {
       // In fixed mode the algorithm truncates trailing spaces and possibly the
       // radix point. There's no good guess for the position of the radix point
       // therefore scan the output after the first digit.
+
       __result.__radix_point = _VSTD::find(__first, __result.__last, '.');
     }
   }
 
   // clang-format off
   _LIBCPP_ASSERT((__result.__integral != __result.__last) &&
                  (__result.__radix_point == __result.__last || *__result.__radix_point == '.') &&
                  (__result.__exponent == __result.__last || *__result.__exponent == 'e'),
_LIBCPP_HIDE_FROM_ABI __float_result __format_buffer(
     _Tp __value,
     bool __negative,
     bool __has_precision,
     __format_spec::__sign __sign,
     __format_spec::__type __type) {
   char* __first = __formatter::__insert_sign(__buffer.begin(), __negative, __sign);
   switch (__type) {
   case __format_spec::__type::__default:
+    if (__has_precision)
+      return __formatter::__format_buffer_general_lower_case(__buffer, __value, __buffer.__precision(), __first);
+    else
       return __formatter::__format_buffer_default(__buffer, __value, __first);
 
   case __format_spec::__type::__hexfloat_lower_case:
     return __formatter::__format_buffer_hexadecimal_lower_case(
         __buffer, __value, __has_precision ? __buffer.__precision() : -1, __first);
 
   case __format_spec::__type::__hexfloat_upper_case:
     return __formatter::__format_buffer_hexadecimal_upper_case(
         __buffer, __value, __has_precision ? __buffer.__precision() : -1, __first);
__format_floating_point(_Tp __value, auto& __ctx, __format_spec::__parsed_specifications<_CharT> __specs)
 
   // TODO FMT _Fp should just be _Tp when to_chars has proper long double support.
   using _Fp = conditional_t<same_as<_Tp, long double>, double, _Tp>;
   // Force the type of the precision to avoid -1 to become an unsigned value.
   __float_buffer<_Fp> __buffer(__specs.__precision_);
   __float_result __result = __formatter::__format_buffer(
       __buffer, __value, __negative, (__specs.__has_precision()), __specs.__std_.__sign_, __specs.__std_.__type_);
 
-  if (__specs.__std_.__alternate_form_ && __result.__radix_point == __result.__last) {
+  if (__specs.__std_.__alternate_form_) {
+    if (__result.__radix_point == __result.__last) {
       *__result.__last++ = '.';
 
       // When there is an exponent the point needs to be moved before the
       // exponent. When there's no exponent the rotate does nothing. Since
       // rotate tests whether the operation is a nop, call it unconditionally.
       _VSTD::rotate(__result.__exponent, __result.__last - 1, __result.__last);
       __result.__radix_point = __result.__exponent;
 
       // The radix point is always placed before the exponent.
       // - No exponent needs to point to the new last.
       // - An exponent needs to move one position to the right.
       // So it's safe to increment the value unconditionally.
       ++__result.__exponent;
     }
 
+    // [format.string.std]/6
+    //   In addition, for g and G conversions, trailing zeros are not removed
+    //   from the result.
+    //
+    // If the type option for a floating-point type is none it may use the
+    // general formatting, but it's not a g or G conversion. So in that case
+    // the formatting should not append trailing zeros.
+    bool __is_general = __specs.__std_.__type_ == __format_spec::__type::__general_lower_case ||
+                        __specs.__std_.__type_ == __format_spec::__type::__general_upper_case;
+
+    if (__is_general) {
+      // https://en.cppreference.com/w/c/io/fprintf
+      // Let P equal the precision if nonzero, 6 if the precision is not
+      // specified, or 1 if the precision is 0. Then, if a conversion with
+      // style E would have an exponent of X:
+      int __p = _VSTD::max(1, (__specs.__has_precision() ? __specs.__precision_ : 6));
+      if (__result.__exponent == __result.__last)
+        // if P > X >= -4, the conversion is with style f or F and precision P - 1 - X.
+        // By including the radix point it calculates P - (1 + X)
+        __p -= __result.__radix_point - __buffer.begin();
+      else
+        // otherwise, the conversion is with style e or E and precision P - 1.
+        --__p;
+
+      ptrdiff_t __precision = (__result.__exponent - __result.__radix_point) - 1;
+      if (__precision < __p)
+        __buffer.__add_trailing_zeros(__p - __precision);
+    }
+  }
+
 #  ifndef _LIBCPP_HAS_NO_LOCALIZATION
   if (__specs.__std_.__locale_specific_form_)
     return __formatter::__format_locale_specific_form(__ctx.out(), __buffer, __result, __ctx.locale(), __specs);
 #  endif
 
   ptrdiff_t __size         = __result.__last - __buffer.begin();
   int __num_trailing_zeros = __buffer.__num_trailing_zeros();
   if (__size + __num_trailing_zeros >= __specs.__width_) {

libcxx/include/__format/parser_std_format_spec.h

default:
     std::__throw_format_error("The format-spec type has a type not supported for an integer argument");
   }
 }
 
 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_floating_point(__parser<_CharT>& __parser) {
   switch (__parser.__type_) {
   case __format_spec::__type::__default:
-    // When no precision specified then it keeps default since that
-    // formatting differs from the other types.
-    if (__parser.__precision_as_arg_ || __parser.__precision_ != -1)
-      __parser.__type_ = __format_spec::__type::__general_lower_case;
-    break;
   case __format_spec::__type::__hexfloat_lower_case:
   case __format_spec::__type::__hexfloat_upper_case:
     // Precision specific behavior will be handled later.
     break;
   case __format_spec::__type::__scientific_lower_case:
   case __format_spec::__type::__scientific_upper_case:
   case __format_spec::__type::__fixed_lower_case:
   case __format_spec::__type::__fixed_upper_case:

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

void format_test_floating_point_general_lower_case(TestFunction check) {
   check.template operator()<"answer is '{:+g}'">(SV("answer is '-nan'"), nan_neg);
   check.template operator()<"answer is '{: g}'">(SV("answer is '-nan'"), nan_neg);
 
   // *** alternate form **
   // When precision is zero there's no decimal point except when the alternate form is specified.
   check.template operator()<"answer is '{:.0g}'">(SV("answer is '0'"), F(0));
   check.template operator()<"answer is '{:#.0g}'">(SV("answer is '0.'"), F(0));
 
-  check.template operator()<"answer is '{:#g}'">(SV("answer is '0.'"), F(0));
-  check.template operator()<"answer is '{:#g}'">(SV("answer is '2.5'"), F(2.5));
+  check.template operator()<"answer is '{:#g}'">(SV("answer is '0.00000'"), F(0));
+  check.template operator()<"answer is '{:#g}'">(SV("answer is '2.50000'"), F(2.5));
 
   check.template operator()<"answer is '{:#g}'">(SV("answer is 'inf'"), std::numeric_limits<F>::infinity());
   check.template operator()<"answer is '{:#g}'">(SV("answer is '-inf'"), -std::numeric_limits<F>::infinity());
 
   check.template operator()<"answer is '{:#g}'">(SV("answer is 'nan'"), nan_pos);
   check.template operator()<"answer is '{:#g}'">(SV("answer is '-nan'"), nan_neg);
 
   // *** zero-padding & width ***
void format_test_floating_point_general_lower_case(TestFunction check) {
   check.template operator()<"answer is '{:.0g}'">(SV("answer is '0.03'"), 0.03125);
   check.template operator()<"answer is '{:.1g}'">(SV("answer is '0.03'"), 0.03125);
   check.template operator()<"answer is '{:.2g}'">(SV("answer is '0.031'"), 0.03125);
   check.template operator()<"answer is '{:.3g}'">(SV("answer is '0.0312'"), 0.03125);
   check.template operator()<"answer is '{:.4g}'">(SV("answer is '0.03125'"), 0.03125);
   check.template operator()<"answer is '{:.5g}'">(SV("answer is '0.03125'"), 0.03125);
   check.template operator()<"answer is '{:.10g}'">(SV("answer is '0.03125'"), 0.03125);
 
+  // *** precision & alternate form ***
+
+  // Output validated with  printf("%#xg")
+  check.template operator()<"answer is '{:#.{}g}'">(SV("answer is '1.'"), 1.2, 0);
+  check.template operator()<"answer is '{:#.{}g}'">(SV("answer is '1.'"), 1.2, 1);
+  check.template operator()<"answer is '{:#.{}g}'">(SV("answer is '1.2'"), 1.2, 2);
+  check.template operator()<"answer is '{:#.{}g}'">(SV("answer is '1.20'"), 1.2, 3);
+  check.template operator()<"answer is '{:#.{}g}'">(SV("answer is '1.200'"), 1.2, 4);
+  check.template operator()<"answer is '{:#.{}g}'">(SV("answer is '1.2000'"), 1.2, 5);
+  check.template operator()<"answer is '{:#.{}g}'">(SV("answer is '1.20000'"), 1.2, 6);
+
+  check.template operator()<"answer is '{:#.{}g}'">(SV("answer is '1.e+03'"), 1200.0, 0);
+  check.template operator()<"answer is '{:#.{}g}'">(SV("answer is '1.e+03'"), 1200.0, 1);
+  check.template operator()<"answer is '{:#.{}g}'">(SV("answer is '1.2e+03'"), 1200.0, 2);
+  check.template operator()<"answer is '{:#.{}g}'">(SV("answer is '1.20e+03'"), 1200.0, 3);
+  check.template operator()<"answer is '{:#.{}g}'">(SV("answer is '1200.'"), 1200.0, 4);
+  check.template operator()<"answer is '{:#.{}g}'">(SV("answer is '1200.0'"), 1200.0, 5);
+  check.template operator()<"answer is '{:#.{}g}'">(SV("answer is '1200.00'"), 1200.0, 6);
+
+  check.template operator()<"answer is '{:#.{}g}'">(SV("answer is '1.e+06'"), 1200000.0, 0);
+  check.template operator()<"answer is '{:#.{}g}'">(SV("answer is '1.e+06'"), 1200000.0, 1);
+  check.template operator()<"answer is '{:#.{}g}'">(SV("answer is '1.2e+06'"), 1200000.0, 2);
+  check.template operator()<"answer is '{:#.{}g}'">(SV("answer is '1.20e+06'"), 1200000.0, 3);
+  check.template operator()<"answer is '{:#.{}g}'">(SV("answer is '1.200e+06'"), 1200000.0, 4);
+  check.template operator()<"answer is '{:#.{}g}'">(SV("answer is '1.2000e+06'"), 1200000.0, 5);
+  check.template operator()<"answer is '{:#.{}g}'">(SV("answer is '1.20000e+06'"), 1200000.0, 6);
+
   // *** locale-specific form ***
   // See locale-specific_form.pass.cpp
 }
 
 template <class F, class CharT, class TestFunction>
 void format_test_floating_point_general_upper_case(TestFunction check) {
   auto nan_pos = std::numeric_limits<F>::quiet_NaN();                          // "nan"
   auto nan_neg = std::copysign(nan_pos, static_cast<decltype(nan_pos)>(-1.0)); // "-nan"
void format_test_floating_point_general_upper_case(TestFunction check) {
   check.template operator()<"answer is '{:+G}'">(SV("answer is '-NAN'"), nan_neg);
   check.template operator()<"answer is '{: G}'">(SV("answer is '-NAN'"), nan_neg);
 
   // *** alternate form **
   // When precision is zero there's no decimal point except when the alternate form is specified.
   check.template operator()<"answer is '{:.0G}'">(SV("answer is '0'"), F(0));
   check.template operator()<"answer is '{:#.0G}'">(SV("answer is '0.'"), F(0));
 
-  check.template operator()<"answer is '{:#G}'">(SV("answer is '0.'"), F(0));
-  check.template operator()<"answer is '{:#G}'">(SV("answer is '2.5'"), F(2.5));
+  check.template operator()<"answer is '{:#G}'">(SV("answer is '0.00000'"), F(0));
+  check.template operator()<"answer is '{:#G}'">(SV("answer is '2.50000'"), F(2.5));
 
   check.template operator()<"answer is '{:#G}'">(SV("answer is 'INF'"), std::numeric_limits<F>::infinity());
   check.template operator()<"answer is '{:#G}'">(SV("answer is '-INF'"), -std::numeric_limits<F>::infinity());
 
   check.template operator()<"answer is '{:#G}'">(SV("answer is 'NAN'"), nan_pos);
   check.template operator()<"answer is '{:#G}'">(SV("answer is '-NAN'"), nan_neg);
 
   // *** zero-padding & width ***
void format_test_floating_point_general_upper_case(TestFunction check) {
   check.template operator()<"answer is '{:.0G}'">(SV("answer is '0.03'"), 0.03125);
   check.template operator()<"answer is '{:.1G}'">(SV("answer is '0.03'"), 0.03125);
   check.template operator()<"answer is '{:.2G}'">(SV("answer is '0.031'"), 0.03125);
   check.template operator()<"answer is '{:.3G}'">(SV("answer is '0.0312'"), 0.03125);
   check.template operator()<"answer is '{:.4G}'">(SV("answer is '0.03125'"), 0.03125);
   check.template operator()<"answer is '{:.5G}'">(SV("answer is '0.03125'"), 0.03125);
   check.template operator()<"answer is '{:.10G}'">(SV("answer is '0.03125'"), 0.03125);
 
+  // *** precision & alternate form ***
+
+  // Output validated with  printf("%#xg")
+  check.template operator()<"answer is '{:#.{}G}'">(SV("answer is '1.'"), 1.2, 0);
+  check.template operator()<"answer is '{:#.{}G}'">(SV("answer is '1.'"), 1.2, 1);
+  check.template operator()<"answer is '{:#.{}G}'">(SV("answer is '1.2'"), 1.2, 2);
+  check.template operator()<"answer is '{:#.{}G}'">(SV("answer is '1.20'"), 1.2, 3);
+  check.template operator()<"answer is '{:#.{}G}'">(SV("answer is '1.200'"), 1.2, 4);
+  check.template operator()<"answer is '{:#.{}G}'">(SV("answer is '1.2000'"), 1.2, 5);
+  check.template operator()<"answer is '{:#.{}G}'">(SV("answer is '1.20000'"), 1.2, 6);
+
+  check.template operator()<"answer is '{:#.{}G}'">(SV("answer is '1.E+03'"), 1200.0, 0);
+  check.template operator()<"answer is '{:#.{}G}'">(SV("answer is '1.E+03'"), 1200.0, 1);
+  check.template operator()<"answer is '{:#.{}G}'">(SV("answer is '1.2E+03'"), 1200.0, 2);
+  check.template operator()<"answer is '{:#.{}G}'">(SV("answer is '1.20E+03'"), 1200.0, 3);
+  check.template operator()<"answer is '{:#.{}G}'">(SV("answer is '1200.'"), 1200.0, 4);
+  check.template operator()<"answer is '{:#.{}G}'">(SV("answer is '1200.0'"), 1200.0, 5);
+  check.template operator()<"answer is '{:#.{}G}'">(SV("answer is '1200.00'"), 1200.0, 6);
+
+  check.template operator()<"answer is '{:#.{}G}'">(SV("answer is '1.E+06'"), 1200000.0, 0);
+  check.template operator()<"answer is '{:#.{}G}'">(SV("answer is '1.E+06'"), 1200000.0, 1);
+  check.template operator()<"answer is '{:#.{}G}'">(SV("answer is '1.2E+06'"), 1200000.0, 2);
+  check.template operator()<"answer is '{:#.{}G}'">(SV("answer is '1.20E+06'"), 1200000.0, 3);
+  check.template operator()<"answer is '{:#.{}G}'">(SV("answer is '1.200E+06'"), 1200000.0, 4);
+  check.template operator()<"answer is '{:#.{}G}'">(SV("answer is '1.2000E+06'"), 1200000.0, 5);
+  check.template operator()<"answer is '{:#.{}G}'">(SV("answer is '1.20000E+06'"), 1200000.0, 6);
+
   // *** locale-specific form ***
   // See locale-specific_form.pass.cpp
 }
 
 template <class F, class CharT, class TestFunction>
 void format_test_floating_point_default(TestFunction check) {
   auto nan_pos = std::numeric_limits<F>::quiet_NaN();                          // "nan"
   auto nan_neg = std::copysign(nan_pos, static_cast<decltype(nan_pos)>(-1.0)); // "-nan"
void format_test_floating_point_default_precision(TestFunction check) {
   check.template operator()<"answer is '{:.0}'">(SV("answer is '0.03'"), 0.03125);
   check.template operator()<"answer is '{:.1}'">(SV("answer is '0.03'"), 0.03125);
   check.template operator()<"answer is '{:.2}'">(SV("answer is '0.031'"), 0.03125);
   check.template operator()<"answer is '{:.3}'">(SV("answer is '0.0312'"), 0.03125);
   check.template operator()<"answer is '{:.4}'">(SV("answer is '0.03125'"), 0.03125);
   check.template operator()<"answer is '{:.5}'">(SV("answer is '0.03125'"), 0.03125);
   check.template operator()<"answer is '{:.10}'">(SV("answer is '0.03125'"), 0.03125);
 
+  // *** precision & alternate form ***
+
+  check.template operator()<"answer is '{:#.{}}'">(SV("answer is '1.'"), 1.2, 0);
+  check.template operator()<"answer is '{:#.{}}'">(SV("answer is '1.'"), 1.2, 1);
+  check.template operator()<"answer is '{:#.{}}'">(SV("answer is '1.2'"), 1.2, 2);
+  check.template operator()<"answer is '{:#.{}}'">(SV("answer is '1.2'"), 1.2, 3);
+  check.template operator()<"answer is '{:#.{}}'">(SV("answer is '1.2'"), 1.2, 4);
+  check.template operator()<"answer is '{:#.{}}'">(SV("answer is '1.2'"), 1.2, 5);
+  check.template operator()<"answer is '{:#.{}}'">(SV("answer is '1.2'"), 1.2, 6);
+
+  check.template operator()<"answer is '{:#.{}}'">(SV("answer is '1.e+03'"), 1200.0, 0);
+  check.template operator()<"answer is '{:#.{}}'">(SV("answer is '1.e+03'"), 1200.0, 1);
+  check.template operator()<"answer is '{:#.{}}'">(SV("answer is '1.2e+03'"), 1200.0, 2);
+  check.template operator()<"answer is '{:#.{}}'">(SV("answer is '1.2e+03'"), 1200.0, 3);
+  check.template operator()<"answer is '{:#.{}}'">(SV("answer is '1200.'"), 1200.0, 4);
+  check.template operator()<"answer is '{:#.{}}'">(SV("answer is '1200.'"), 1200.0, 5);
+  check.template operator()<"answer is '{:#.{}}'">(SV("answer is '1200.'"), 1200.0, 6);
+
+  check.template operator()<"answer is '{:#.{}}'">(SV("answer is '1.e+06'"), 1200000.0, 0);
+  check.template operator()<"answer is '{:#.{}}'">(SV("answer is '1.e+06'"), 1200000.0, 1);
+  check.template operator()<"answer is '{:#.{}}'">(SV("answer is '1.2e+06'"), 1200000.0, 2);
+  check.template operator()<"answer is '{:#.{}}'">(SV("answer is '1.2e+06'"), 1200000.0, 3);
+  check.template operator()<"answer is '{:#.{}}'">(SV("answer is '1.2e+06'"), 1200000.0, 4);
+  check.template operator()<"answer is '{:#.{}}'">(SV("answer is '1.2e+06'"), 1200000.0, 5);
+  check.template operator()<"answer is '{:#.{}}'">(SV("answer is '1.2e+06'"), 1200000.0, 6);
+
   // *** locale-specific form ***
   // See locale-specific_form.pass.cpp
 }
 
 template <class F, class CharT, class TestFunction, class ExceptionTest>
 void format_test_floating_point(TestFunction check, ExceptionTest check_exception) {
   format_test_floating_point_hex_lower_case<F, CharT>(check);
   format_test_floating_point_hex_upper_case<F, CharT>(check);