[flang] Fix F5.3 formatting of 0.025

[klausler]

Summary

Fix F output editing in the Fortran runtime so that it
respects the 'd' count of digits after the decimal mark.

flang/runtime/edit-output.h

 template <typename INT = std::int64_t, typename UINT = std::uint64_t>
 bool EditIntegerOutput(IoStatementState &, const DataEdit &, INT);
 
 // Encapsulates the state of a REAL output conversion.
 class RealOutputEditingBase {
 protected:
   explicit RealOutputEditingBase(IoStatementState &io) : io_{io} {}
 
-  static bool IsDecimalNumber(const char *p) {
-    if (!p) {
+  static bool IsInfOrNaN(const decimal::ConversionToDecimalResult &res) {
+    const char *p{res.str};
+    if (!p || res.length < 1) {
       return false;
     }
     if (*p == '-' || *p == '+') {
+      if (res.length == 1) {
+        return false;
+      }
       ++p;
     }
-    return *p >= '0' && *p <= '9';
+    return *p < '0' || *p > '9';
   }
 
   const char *FormatExponent(int, const DataEdit &edit, int &length);
   bool EmitPrefix(const DataEdit &, std::size_t length, std::size_t width);
   bool EmitSuffix(const DataEdit &);
 
   IoStatementState &io_;
   int trailingBlanks_{0}; // created when Gw editing maps to Fw

flang/runtime/edit-output.cpp

bool RealOutputEditing<binaryPrecision>::EditEorDOutput(const DataEdit &edit) {
   } else if (scale > 0) {
     ++significantDigits;
     scale = std::min(scale, significantDigits + 1);
   }
   // In EN editing, multiple attempts may be necessary, so it's in a loop.
   while (true) {
     decimal::ConversionToDecimalResult converted{
         Convert(significantDigits, edit, flags)};
-    if (converted.length > 0 && !IsDecimalNumber(converted.str)) { // Inf, NaN
+    if (IsInfOrNaN(converted)) {
       return EmitPrefix(edit, converted.length, editWidth) &&
           io_.Emit(converted.str, converted.length) && EmitSuffix(edit);
     }
     if (!IsZero()) {
       converted.decimalExponent -= scale;
     }
     if (isEN && scale < 3 && (converted.decimalExponent % 3) != 0) {
       // EN mode: boost the scale and significant digits, try again; need
return EmitPrefix(edit, totalLength, width) &&
         io_.Emit(exponent, expoLength) && EmitSuffix(edit);
   }
 }
 
 // 13.7.2.3.2 in F'2018
 template <int binaryPrecision>
 bool RealOutputEditing<binaryPrecision>::EditFOutput(const DataEdit &edit) {
   int fracDigits{edit.digits.value_or(0)}; // 'd' field
-  int extraDigits{0};
-  int editWidth{edit.width.value_or(0)}; // 'w' field
+  const int editWidth{edit.width.value_or(0)}; // 'w' field
   int flags{0};
   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};
   while (true) {
     decimal::ConversionToDecimalResult converted{
         Convert(extraDigits + fracDigits, edit, flags)};
-    if (converted.length > 0 && !IsDecimalNumber(converted.str)) { // Inf, NaN
+    if (IsInfOrNaN(converted)) {
       return EmitPrefix(edit, converted.length, editWidth) &&
           io_.Emit(converted.str, converted.length) && EmitSuffix(edit);
     }
     int scale{IsZero() ? -1 : edit.modes.scale};
     int expo{converted.decimalExponent - scale};
-    if (expo > extraDigits) {
+    if (expo > extraDigits && extraDigits >= 0) {
       extraDigits = expo;
-      if (flags & decimal::Minimize) {
+      if (!edit.digits.has_value()) { // F0
         fracDigits = sizeof buffer_ - extraDigits - 2; // sign & NUL
       }
-      continue; // try again
+      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))};
     int zeroesBeforePoint{std::max(0, expo - digitsBeforePoint)};
-    int zeroesAfterPoint{std::max(0, -expo)};
+    int zeroesAfterPoint{std::min(fracDigits, std::max(0, -expo))};
     int digitsAfterPoint{convertedDigits - digitsBeforePoint};
     int trailingZeroes{flags & decimal::Minimize
             ? 0
             : std::max(0, fracDigits - (zeroesAfterPoint + digitsAfterPoint))};
     if (digitsBeforePoint + zeroesBeforePoint + zeroesAfterPoint +
             digitsAfterPoint + trailingZeroes ==
         0) {
-      ++zeroesBeforePoint; // "." -> "0."
+      zeroesBeforePoint = 1; // "." -> "0."
     }
     int totalLength{signLength + digitsBeforePoint + zeroesBeforePoint +
         1 /*'.'*/ + zeroesAfterPoint + digitsAfterPoint + trailingZeroes};
     int width{editWidth > 0 ? editWidth : totalLength};
     if (totalLength > width) {
       return io_.EmitRepeated('*', width);
     }
     if (totalLength < width && digitsBeforePoint + zeroesBeforePoint == 0) {

 template <int binaryPrecision>
 DataEdit RealOutputEditing<binaryPrecision>::EditForGOutput(DataEdit edit) {
   edit.descriptor = 'E';
   if (!edit.width.has_value() ||
       (*edit.width > 0 && edit.digits.value_or(-1) == 0)) {
     return edit; // Gw.0 -> Ew.0 for w > 0
   }
   decimal::ConversionToDecimalResult converted{Convert(1, edit)};
-  if (!IsDecimalNumber(converted.str)) { // Inf, NaN
+  if (IsInfOrNaN(converted)) {
     return edit;
   }
   int expo{IsZero() ? 1 : converted.decimalExponent}; // 's'
   int significantDigits{
       edit.digits.value_or(BinaryFloatingPoint::decimalPrecision)}; // 'd'
   if (expo < 0 || expo > significantDigits) {
     return edit; // Ew.d
   }
DataEdit RealOutputEditing<binaryPrecision>::EditForGOutput(DataEdit edit) {
   return edit;
 }
 
 // 13.10.4 in F'2018
 template <int binaryPrecision>
 bool RealOutputEditing<binaryPrecision>::EditListDirectedOutput(
     const DataEdit &edit) {
   decimal::ConversionToDecimalResult converted{Convert(1, edit)};
-  if (!IsDecimalNumber(converted.str)) { // Inf, NaN
+  if (IsInfOrNaN(converted)) {
     return EditEorDOutput(edit);
   }
   int expo{converted.decimalExponent};
   if (expo < 0 || expo > BinaryFloatingPoint::decimalPrecision) {
     DataEdit copy{edit};
     copy.modes.scale = 1; // 1P
     return EditEorDOutput(copy);
   }

flang/unittests/Runtime/hello.cpp

realTest("(EN319.310,';')", u.d,
       " 179."
       "769313486231570814527423731704356798070567525844996598917476803157260780"
       "028538760589558632766878171540458953514382464234321326889464182768467546"
       "703537516986049910576551282076245490090389328944075868508455133942304583"
       "236903222948165808559332123348274797826204144723168738177180919299881250"
       "4040261841248583680000+306;");
   realTest("(G0,';')", u.d, ".17976931348623157+309;");
 
+  realTest("(F5.3,';')", 25., "*****;");
+  realTest("(F5.3,';')", 2.5, "2.500;");
+  realTest("(F5.3,';')", 0.25, "0.250;");
+  realTest("(F5.3,';')", 0.025, "0.025;");
+  realTest("(F5.3,';')", 0.0025, "0.003;");
+  realTest("(F5.3,';')", 0.00025, "0.000;");
+  realTest("(F5.3,';')", 0.000025, "0.000;");
+  realTest("(F5.3,';')", -25., "*****;");
+  realTest("(F5.3,';')", -2.5, "*****;");
+  realTest("(F5.3,';')", -0.25, "-.250;");
+  realTest("(F5.3,';')", -0.025, "-.025;");
+  realTest("(F5.3,';')", -0.0025, "-.003;");
+  realTest("(F5.3,';')", -0.00025, "-.000;");
+  realTest("(F5.3,';')", -0.000025, "-.000;");
+
   realInTest("(F18.0)", "                 0", 0x0);
   realInTest("(F18.0)", "                  ", 0x0);
   realInTest("(F18.0)", "                -0", 0x8000000000000000);
   realInTest("(F18.0)", "                 1", 0x3ff0000000000000);
   realInTest("(F18.0)", "              125.", 0x405f400000000000);
   realInTest("(F18.0)", "              12.5", 0x4029000000000000);
   realInTest("(F18.0)", "              1.25", 0x3ff4000000000000);
   realInTest("(F18.0)", "              .125", 0x3fc0000000000000);