[flang] runtime: For Fw.d formatting, don't oscillate forever

[klausler]

Summary

The algorithm for Fw.d output will drive binary to decimal conversion for
an initial fixed number of digits, then adjust that number based on the
result's exposent. For value close to a power of ten, this adjustment
process wouldn't terminate; e.g., formatting 9.999 as F10.2 would start
with 1e2, boost the digits to 2, get 9.99e1, decrease the digits, and loop.
Solve by refusing to boost the digits a second time.

[PeteSteinfeld]

All builds, tests, and looks good.

flang/lib/Decimal/binary-to-decimal.cpp

if ((flags & Minimize) && !x.IsZero()) {
       using Binary = typename Big::Real;
       Binary less{x};
       less.Previous();
       Binary more{x};
       if (!x.IsMaximalFiniteMagnitude()) {
         more.Next();
       }
       number.Minimize(Big{less, rounding}, Big{more, rounding});
-    } else {
     }
     return number.ConvertToDecimal(buffer, size, flags, digits);
   }
 }
 
 template ConversionToDecimalResult ConvertToDecimal<8>(char *, std::size_t,
     enum DecimalConversionFlags, int, enum FortranRounding,
     BinaryFloatingPointNumber<8>);

flang/runtime/edit-output.cpp

if (editWidth == 0) { // "the processor selects the field width"
     if (!edit.digits.has_value()) { // F0
       flags |= decimal::Minimize;
       fracDigits = sizeof buffer_ - 2; // sign & NUL
     }
   }
   // Multiple conversions may be needed to get the right number of
   // effective rounded fractional digits.
   int extraDigits{0};
+  bool canIncrease{true};
   while (true) {
     decimal::ConversionToDecimalResult converted{
         Convert(extraDigits + fracDigits, edit, flags)};
     if (IsInfOrNaN(converted)) {
       return EmitPrefix(edit, converted.length, editWidth) &&
           io_.Emit(converted.str, converted.length) && EmitSuffix(edit);
     }
     int scale{IsZero() ? 1 : edit.modes.scale}; // kP
     int expo{converted.decimalExponent + scale};
-    if (expo > extraDigits && extraDigits >= 0) {
+    if (expo > extraDigits && extraDigits >= 0 && canIncrease) {
       extraDigits = expo;
       if (!edit.digits.has_value()) { // F0
         fracDigits = sizeof buffer_ - extraDigits - 2; // sign & NUL
       }
+      canIncrease = false; // only once
       continue;
     } else if (expo < extraDigits && extraDigits > -fracDigits) {
       extraDigits = std::max(expo, -fracDigits);
       continue;
     }
     int signLength{*converted.str == '-' || *converted.str == '+' ? 1 : 0};
     int convertedDigits{static_cast<int>(converted.length) - signLength};
     int digitsBeforePoint{std::max(0, std::min(expo, convertedDigits))};

flang/unittests/Runtime/NumericalFormatTest.cpp

static const std::vector<IndividualTestCaseTy> individualTestCases{
       {"(F5.3,';')", 0.000025, "0.000;"},
       {"(F5.3,';')", -25., "*****;"},
       {"(F5.3,';')", -2.5, "*****;"},
       {"(F5.3,';')", -0.25, "-.250;"},
       {"(F5.3,';')", -0.025, "-.025;"},
       {"(F5.3,';')", -0.0025, "-.003;"},
       {"(F5.3,';')", -0.00025, "-.000;"},
       {"(F5.3,';')", -0.000025, "-.000;"},
+      {"(F5.3,';')", 99.999, "*****;"},
+      {"(F5.3,';')", 9.9999, "*****;"},
+      {"(F5.3,';')", 0.99999, "1.000;"},
+      {"(F5.3,';')", 0.099999, "0.100;"},
+      {"(F5.3,';')", 0.0099999, "0.010;"},
+      {"(F5.3,';')", 0.00099999, "0.001;"},
+      {"(F5.3,';')", 0.000099999, "0.000;"},
+      {"(F5.3,';')", -99.999, "*****;"},
+      {"(F5.3,';')", -9.9999, "*****;"},
+      {"(F5.3,';')", -0.99999, "*****;"},
+      {"(F5.3,';')", -0.099999, "-.100;"},
+      {"(F5.3,';')", -0.0099999, "-.010;"},
+      {"(F5.3,';')", -0.00099999, "-.001;"},
+      {"(F5.3,';')", -0.000099999, "-.000;"},
   };
 
   for (auto const &[format, value, expect] : individualTestCases) {
     ASSERT_TRUE(CompareFormatReal(format, value, expect))
         << "Failed to format " << format << ", expected " << expect;
   }
 }