[flang][runtime] Improve G0 output editing

[klausler]

Summary

G0 output editing should never overflow an output field and fill it
with asterisks. It should also never elide the "E" in an exponent
field, even if it has more than three digits.

flang/runtime/edit-output.cpp

if (edit.expoDigits) {
     }
   } else { // ensure at least two exponent digits
     while (exponent + 2 > eEnd) {
       *--exponent = '0';
     }
   }
   *--exponent = expo < 0 ? '-' : '+';
   if (edit.expoDigits || edit.IsListDirected() || exponent + 3 == eEnd) {
-    *--exponent = edit.descriptor == 'D' ? 'D' : 'E'; // not 'G'
+    *--exponent = edit.descriptor == 'D' ? 'D' : 'E'; // not 'G' or 'Q'
   }
   length = eEnd - exponent;
   return overflow ? nullptr : exponent;
 }
 
 bool RealOutputEditingBase::EmitPrefix(
     const DataEdit &edit, std::size_t length, std::size_t width) {
   if (edit.IsListDirected()) {
bool RealOutputEditing<binaryPrecision>::EditEorDOutput(const DataEdit &edit) {
   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
+        significantDigits = 1;
       }
     } else { // E0
       flags |= decimal::Minimize;
       significantDigits =
           sizeof buffer_ - 5; // sign, NUL, + 3 extra for EN scaling
     }
   }
   bool isEN{edit.variation == 'N'};

 // 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 (editWidth > 0 && significantDigits == 0) {
-    return edit; // Gw.0 -> Ew.0 for w > 0
+    return edit; // Gw.0Ee -> Ew.0Ee 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; // Inf/Nan -> Ew.d (same as Fw.d)
   }
   int expo{IsZero() ? 1 : converted.decimalExponent}; // 's'
   if (expo < 0 || expo > significantDigits) {
-    return edit; // Ew.d
+    if (editWidth == 0 && !edit.expoDigits) { // G0.d -> G0.dE0
+      edit.expoDigits = 0;
+    }
+    return edit; // Ew.dEe
   }
   edit.descriptor = 'F';
   edit.modes.scale = 0; // kP is ignored for G when no exponent field
   trailingBlanks_ = 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_);

flang/unittests/Runtime/NumericalFormatTest.cpp

static const std::vector<TestCaseTy> testCases{
               {"(G0,';')", "NaN;"},
           }},
       {// 0.1 rounded
           0x3fb999999999999a,
           {
               {"(E62.55,';')",
                   " 0.1000000000000000055511151231257827021181583404541015625E+"
                   "00;"},
-              {"(E0.0,';')", "0.E+00;"},
+              {"(E0.0,';')", ".1E+00;"},
               {"(E0.55,';')",
-                  "0.1000000000000000055511151231257827021181583404541015625E+"
+                  ".1000000000000000055511151231257827021181583404541015625E+"
                   "00;"},
               {"(E0,';')", ".1E+00;"},
               {"(F58.55,';')",
                   " 0."
                   "1000000000000000055511151231257827021181583404541015625;"},
               {"(F0.0,';')", "0.;"},
               {"(F0.55,';')",
                   ".1000000000000000055511151231257827021181583404541015625;"},
static const std::vector<TestCaseTy> testCases{
                   "686768187039560310624931945271591492455329305456544401127480"
                   "129709999541931989409080416563324524757147869014726780159355"
                   "238611550134803526493472019379026810710749170333222684475333"
                   "572083243193609238289345836806010601150616980975307834227731"
                   "832924790498252473077637592724787465608477820373446969953364"
                   "701797267771758512566055119913150489110145103786273816725095"
                   "583738973359899366480994116420570263709027924276754456522908"
                   "75386825064197182655334472656250-323;"},
-              {"(G0,';')", ".5-323;"},
+              {"(G0,';')", ".5E-323;"},
               {"(E757.750,';')",
                   " 0."
                   "494065645841246544176568792868221372365059802614324764425585"
                   "682500675507270208751865299836361635992379796564695445717730"
                   "926656710355939796398774796010781878126300713190311404527845"
                   "817167848982103688718636056998730723050006387409153564984387"
                   "312473397273169615140031715385398074126238565591171026658556"
                   "686768187039560310624931945271591492455329305456544401127480"
static const std::vector<TestCaseTy> testCases{
                   "945158045160505091539985658247081864511353793580499211598108"
                   "576605199243335211435239014879569960959128889160299264151106"
                   "346631339366347758651302937176204732563178148566435087212282"
                   "863764204484681140761391147706280168985324411002416144742161"
                   "856716615054015428508471675290190316132277889672970737312333"
                   "408698898317506783884692609277397797285865965494109136909540"
                   "61364675687023986783152906809846172109246253967285156250-"
                   "307;"},
-              {"(G0,';')", ".22250738585072014-307;"},
+              {"(G0,';')", ".22250738585072014E-307;"},
           }},
       {// greatest finite
           0x7fefffffffffffffuLL,
           {
               {"(E32.17,';')", "         0.17976931348623157+309;"},
               {"(E317.310,';')",
                   " 0."
                   "179769313486231570814527423731704356798070567525844996598917"
static const std::vector<TestCaseTy> testCases{
               {"(EN319.310,';')",
                   " 179."
                   "769313486231570814527423731704356798070567525844996598917476"
                   "803157260780028538760589558632766878171540458953514382464234"
                   "321326889464182768467546703537516986049910576551282076245490"
                   "090389328944075868508455133942304583236903222948165808559332"
                   "123348274797826204144723168738177180919299881250404026184124"
                   "8583680000+306;"},
-              {"(G0,';')", ".17976931348623157+309;"},
+              {"(G0,';')", ".17976931348623157E+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