[flang][runtime] Don't emit any leading blanks for G0/E0 output editing

[klausler]

Summary

There were cases where E0.d output editing (or G0.d editing that is converted
to E0.d) would emit one or more leading blank characters; fix them.

flang/runtime/edit-output.cpp

 bool RealOutputEditing<binaryPrecision>::EditEorDOutput(const DataEdit &edit) {
   int editDigits{edit.digits.value_or(0)}; // 'd' field
   int editWidth{edit.width.value_or(0)}; // 'w' field
   int significantDigits{editDigits};
   int flags{0};
   if (edit.modes.editingFlags & signPlus) {
     flags |= decimal::AlwaysSign;
   }
+  bool noLeadingSpaces{editWidth == 0};
   if (editWidth == 0) { // "the processor selects the field width"
     if (edit.digits.has_value()) { // E0.d
       if (editDigits == 0) { // E0.0
         editWidth = 7; // -.0E+ee
       } else {
         editWidth = editDigits + 6; // -.666E+ee
       }
     } else { // E0
while (true) {
     if (totalLength > width) {
       return io_.EmitRepeated('*', width);
     }
     if (totalLength < width && digitsBeforePoint == 0 &&
         zeroesBeforePoint == 0) {
       zeroesBeforePoint = 1;
       ++totalLength;
     }
+    if (totalLength < width && noLeadingSpaces) {
+      width = totalLength;
+    }
     return EmitPrefix(edit, totalLength, width) &&
         io_.Emit(converted.str, signLength + digitsBeforePoint) &&
         io_.EmitRepeated('0', zeroesBeforePoint) &&
         io_.Emit(edit.modes.editingFlags & decimalComma ? "," : ".", 1) &&
         io_.EmitRepeated('0', zeroesAfterPoint) &&
         io_.Emit(
             converted.str + signLength + digitsBeforePoint, digitsAfterPoint) &&
         io_.EmitRepeated('0', trailingZeroes) &&
return EmitPrefix(edit, totalLength, width) &&
         io_.EmitRepeated(' ', trailingBlanks_) && EmitSuffix(edit);
   }
 }
 
 // 13.7.5.2.3 in F'2018
 template <int binaryPrecision>
 DataEdit RealOutputEditing<binaryPrecision>::EditForGOutput(DataEdit edit) {
   edit.descriptor = 'E';
+  int editWidth{edit.width.value_or(0)};
   int significantDigits{
       edit.digits.value_or(BinaryFloatingPoint::decimalPrecision)}; // 'd'
-  if (!edit.width.has_value() || (*edit.width > 0 && significantDigits == 0)) {
+  if (editWidth > 0 && significantDigits == 0) {
     return edit; // Gw.0 -> Ew.0 for w > 0
   }
   int flags{0};
   if (edit.modes.editingFlags & signPlus) {
     flags |= decimal::AlwaysSign;
   }
   decimal::ConversionToDecimalResult converted{
       Convert(significantDigits, edit.modes.round, flags)};
   if (IsInfOrNaN(converted)) {
-    return edit;
+    return edit; // Inf/Nan -> Ew.d (same as Fw.d)
   }
   int expo{IsZero() ? 1 : converted.decimalExponent}; // 's'
   if (expo < 0 || expo > significantDigits) {
     return edit; // Ew.d
   }
   edit.descriptor = 'F';
   edit.modes.scale = 0; // kP is ignored for G when no exponent field
   trailingBlanks_ = 0;
-  int editWidth{edit.width.value_or(0)};
   if (editWidth > 0) {
     int expoDigits{edit.expoDigits.value_or(0)};
     trailingBlanks_ = expoDigits > 0 ? expoDigits + 2 : 4; // 'n'
     *edit.width = std::max(0, editWidth - trailingBlanks_);
   }
   if (edit.digits.has_value()) {
     *edit.digits = std::max(0, *edit.digits - expo);
   }

flang/unittests/Runtime/NumericalFormatTest.cpp

static constexpr std::pair<const char *, const char *> zeroes[]{
       {"(2P,E32.17,';')", "         00.0000000000000000E+00;"},
       {"(-1P,E32.17,';')", "         0.00000000000000000E+00;"},
       {"(G0,';')", "0.;"},
   };
 
   for (auto const &[format, expect] : zeroes) {
     std::string got;
     ASSERT_TRUE(CompareFormatReal(format, 0.0, expect, got))
-        << "Failed to format " << format << ", expected " << expect << ", got "
-        << got;
+        << "Failed to format " << format << ", expected '" << expect
+        << "', got '" << got << "'";
   }
 }
 
 TEST(IOApiTests, FormatOnes) {
   static constexpr std::pair<const char *, const char *> ones[]{
       {"(E32.17,';')", "         0.10000000000000000E+01;"},
       {"(F32.17,';')", "             1.00000000000000000;"},
       {"(G32.17,';')", "          1.0000000000000000    ;"},
static constexpr std::pair<const char *, const char *> ones[]{
       {"(-1P,E32.17,';')", "         0.01000000000000000E+02;"},
       {"(-1P,G32.17,';')", "          1.0000000000000000    ;"},
       {"(G0,';')", "1.;"},
   };
 
   for (auto const &[format, expect] : ones) {
     std::string got;
     ASSERT_TRUE(CompareFormatReal(format, 1.0, expect, got))
-        << "Failed to format " << format << ", expected " << expect << ", got "
-        << got;
+        << "Failed to format " << format << ", expected '" << expect
+        << "', got '" << got << "'";
   }
 }
 
 TEST(IOApiTests, FormatNegativeOnes) {
   static constexpr std::tuple<const char *, const char *> negOnes[]{
       {"(E32.17,';')", "        -0.10000000000000000E+01;"},
       {"(F32.17,';')", "            -1.00000000000000000;"},
       {"(G32.17,';')", "         -1.0000000000000000    ;"},
       {"(G0,';')", "-1.;"},
   };
   for (auto const &[format, expect] : negOnes) {
     std::string got;
     ASSERT_TRUE(CompareFormatReal(format, -1.0, expect, got))
-        << "Failed to format " << format << ", expected " << expect << ", got "
-        << got;
+        << "Failed to format " << format << ", expected '" << expect
+        << "', got '" << got << "'";
   }
 }
 
 // Each test case contains a raw uint64, a format string for a real value, and
 // the expected resulting string from formatting the raw uint64. The double
 // representation of the uint64 is commented above each test case.
 TEST(IOApiTests, FormatDoubleValues) {
 
static const std::vector<TestCaseTy> testCases{
               {"(G0,';')", "NaN;"},
           }},
       {// 0.1 rounded
           0x3fb999999999999a,
           {
               {"(E62.55,';')",
                   " 0.1000000000000000055511151231257827021181583404541015625E+"
                   "00;"},
-              {"(E0.0,';')", " 0.E+00;"},
+              {"(E0.0,';')", "0.E+00;"},
               {"(E0.55,';')",
                   "0.1000000000000000055511151231257827021181583404541015625E+"
                   "00;"},
               {"(E0,';')", ".1E+00;"},
               {"(F58.55,';')",
                   " 0."
                   "1000000000000000055511151231257827021181583404541015625;"},
               {"(F0.0,';')", "0.;"},
static const std::vector<TestCaseTy> testCases{
               {"(G0,';')", ".17976931348623157+309;"},
           }},
   };
 
   for (auto const &[value, cases] : testCases) {
     for (auto const &[format, expect] : cases) {
       std::string got;
       ASSERT_TRUE(CompareFormatReal(format, value, expect, got))
-          << "Failed to format " << format << ", expected " << expect
-          << ", got " << got;
+          << "Failed to format " << format << ", expected '" << expect
+          << "', got '" << got << "'";
     }
   }
 
   using IndividualTestCaseTy = std::tuple<const char *, double, const char *>;
   static const std::vector<IndividualTestCaseTy> individualTestCases{
       {"(F5.3,';')", 25., "*****;"},
       {"(F5.3,';')", 2.5, "2.500;"},
       {"(F5.3,';')", 0.25, "0.250;"},
static const std::vector<IndividualTestCaseTy> individualTestCases{
       {"(F5.3,';')", -0.00049999, "-.000;"},
       {"(F5.3,';')", -0.000099999, "-.000;"},
       {"(F0.1,';')", 0.0, ".0;"},
   };
 
   for (auto const &[format, value, expect] : individualTestCases) {
     std::string got;
     ASSERT_TRUE(CompareFormatReal(format, value, expect, got))
-        << "Failed to format " << format << ", expected " << expect << ", got "
-        << got;
+        << "Failed to format " << format << ", expected '" << expect
+        << "', got '" << got << "'";
   }
 
   // Problematic EN formatting edge cases with rounding
   using IndividualENTestCaseTy = std::tuple<std::uint64_t, const char *>;
   static const std::vector<IndividualENTestCaseTy> individualENTestCases{
       {0x3E11183197785F8C, " 995.0E-12"}, // 0.9950312500000000115852E-09
       {0x3E11180E68455D30, " 995.0E-12"}, // 0.9949999999999999761502E-09
       {0x3E112BD8F4F6B0D7, " 999.5E-12"}, // 0.9994999999999999089118E-09
       {0x3E45794883CA8782, "  10.0E-09"}, // 0.9999499999999999642266E-08
       {0x3F506218230C7482, " 999.9E-06"}, // 0.9999499999999998840761E-03
       {0x3FB99652BD3C3612, " 100.0E-03"}, // 0.9999500000000000055067E+00
       {0x4023E66666666667, "  10.0E+00"}, // 0.9950000000000001065814E+01
   };
 
   for (auto const &[value, expect] : individualENTestCases) {
     std::string got;
     ASSERT_TRUE(CompareFormatReal("(EN10.1)", value, expect, got))
-        << "Failed to format EN10.1, expected " << expect << ", got " << got;
+        << "Failed to format EN10.1, expected '" << expect << "', got '" << got
+        << "'";
   }
 }
 
 //------------------------------------------------------------------------------
 /// Tests for input formatting real values
 //------------------------------------------------------------------------------
 
 // Ensure double input values correctly map to raw uint64 values