[flang] Fine-tune NAN formatted input editing

[klausler]

Summary

Per Fortran 2018, "NAN" and "NAN()" are to be translated into quiet
NaNs, and the other forms are implementation-dependent; I've made
them quiet NaNs too. Also process signs on input NaNs, which seems
wrong but other compilers all do it, and fix some misleading template
argument names noticed along the way.

[vdonaldson]

Thanks for the fix!

flang/lib/Decimal/big-radix-floating-point.h

#endif
   // can't be in a valid floating-point character.
   bool ParseNumber(const char *&, bool &inexact, const char *end);
 
   using Raw = typename Real::RawType;
   constexpr Raw SignBit() const { return Raw{isNegative_} << (Real::bits - 1); }
   constexpr Raw Infinity() const {
     return (Raw{Real::maxExponent} << Real::significandBits) | SignBit();
   }
-  static constexpr Raw NaN() {
+  constexpr Raw NaN(bool isQuiet = true) {
     return (Raw{Real::maxExponent} << Real::significandBits) |
-        (Raw{1} << (Real::significandBits - 2));
+        (Raw{1} << (Real::significandBits - (isQuiet ? 1 : 2))) | SignBit();
   }
 
   Digit digit_[maxDigits]; // in little-endian order: digit_[0] is LSD
   int digits_{0}; // # of elements in digit_[] array; zero when zero
   int digitLimit_{maxDigits}; // precision clamp
   int exponent_{0}; // signed power of ten
   bool isNegative_{false};
   enum FortranRounding rounding_ { RoundNearest };
 };
 } // namespace Fortran::decimal
 #endif

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

if (ParseNumber(p, inexact, limit)) {
     auto result{ConvertToBinary()};
     if (inexact) {
       result.flags =
           static_cast<enum ConversionResultFlags>(result.flags | Inexact);
     }
     return result;
   } else {
     // Could not parse a decimal floating-point number.  p has been
-    // advanced over any leading spaces.
-    if ((!limit || limit >= p + 3) && toupper(p[0]) == 'N' &&
-        toupper(p[1]) == 'A' && toupper(p[2]) == 'N') {
+    // advanced over any leading spaces.  Most Fortran compilers set
+    // the sign bit for -NaN.
+    const char *q{p};
+    if (!limit || q < limit) {
+      isNegative_ = *q == '-';
+      if (isNegative_ || *q == '+') {
+        ++q;
+      }
+    }
+    if ((!limit || limit >= q + 3) && toupper(q[0]) == 'N' &&
+        toupper(q[1]) == 'A' && toupper(q[2]) == 'N') {
       // NaN
-      p += 3;
+      p = q + 3;
+      bool isQuiet{true};
       if ((!limit || p < limit) && *p == '(') {
         int depth{1};
         do {
           ++p;
           if (limit && p >= limit) {
             // Invalid input
-            return {Real{NaN()}, Invalid};
+            return {Real{NaN(false)}, Invalid};
           } else if (*p == '(') {
             ++depth;
           } else if (*p == ')') {
             --depth;
+          } else if (*p != ' ') {
+            // Implementation dependent, but other compilers
+            // all return quiet NaNs.
           }
         } while (depth > 0);
         ++p;
       }
-      return {Real{NaN()}};
-    } else {
-      // Try to parse Inf, maybe with a sign
-      const char *q{p};
-      if (!limit || q < limit) {
-        isNegative_ = *q == '-';
-        if (isNegative_ || *q == '+') {
-          ++q;
-        }
-      }
+      return {Real{NaN(isQuiet)}};
+    } else { // Inf?
       if ((!limit || limit >= q + 3) && toupper(q[0]) == 'I' &&
           toupper(q[1]) == 'N' && toupper(q[2]) == 'F') {
         if ((!limit || limit >= q + 8) && toupper(q[3]) == 'I' &&
             toupper(q[4]) == 'N' && toupper(q[5]) == 'I' &&
             toupper(q[6]) == 'T' && toupper(q[7]) == 'Y') {
           p = q + 8;
         } else {
           p = q + 3;

flang/runtime/edit-output.cpp

return EmitAscii(
         io_, edit.modes.editingFlags & decimalComma ? ";" : ",", 1);
   } else if (edit.descriptor == DataEdit::ListDirectedImaginaryPart) {
     return EmitAscii(io_, ")", 1);
   } else {
     return true;
   }
 }
 
-template <int binaryPrecision>
-decimal::ConversionToDecimalResult RealOutputEditing<binaryPrecision>::Convert(
+template <int KIND>
+decimal::ConversionToDecimalResult RealOutputEditing<KIND>::Convert(
     int significantDigits, enum decimal::FortranRounding rounding, int flags) {
   auto converted{decimal::ConvertToDecimal<binaryPrecision>(buffer_,
       sizeof buffer_, static_cast<enum decimal::DecimalConversionFlags>(flags),
       significantDigits, rounding, x_)};
   if (!converted.str) { // overflow
     io_.GetIoErrorHandler().Crash(
         "RealOutputEditing::Convert : buffer size %zd was insufficient",
         sizeof buffer_);
   }
   return converted;
 }
 
 // 13.7.2.3.3 in F'2018
-template <int binaryPrecision>
-bool RealOutputEditing<binaryPrecision>::EditEorDOutput(const DataEdit &edit) {
+template <int KIND>
+bool RealOutputEditing<KIND>::EditEorDOutput(const DataEdit &edit) {
   addSpaceBeforeCharacter(io_);
   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;
   }
return EmitPrefix(edit, totalLength, width) &&
         EmitAscii(io_, converted.str + signLength + digitsBeforePoint,
             digitsAfterPoint) &&
         EmitRepeated(io_, '0', trailingZeroes) &&
         EmitAscii(io_, exponent, expoLength) && EmitSuffix(edit);
   }
 }
 
 // 13.7.2.3.2 in F'2018
-template <int binaryPrecision>
-bool RealOutputEditing<binaryPrecision>::EditFOutput(const DataEdit &edit) {
+template <int KIND>
+bool RealOutputEditing<KIND>::EditFOutput(const DataEdit &edit) {
   addSpaceBeforeCharacter(io_);
   int fracDigits{edit.digits.value_or(0)}; // 'd' field
   const int editWidth{edit.width.value_or(0)}; // 'w' field
   enum decimal::FortranRounding rounding{edit.modes.round};
   int flags{0};
   if (edit.modes.editingFlags & signPlus) {
     flags |= decimal::AlwaysSign;
   }
return EmitPrefix(edit, totalLength, width) &&
             digitsAfterPoint) &&
         EmitRepeated(io_, '1', trailingOnes) &&
         EmitRepeated(io_, '0', trailingZeroes) &&
         EmitRepeated(io_, ' ', trailingBlanks_) && EmitSuffix(edit);
   }
 }
 
 // 13.7.5.2.3 in F'2018
-template <int binaryPrecision>
-DataEdit RealOutputEditing<binaryPrecision>::EditForGOutput(DataEdit edit) {
+template <int KIND>
+DataEdit RealOutputEditing<KIND>::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.0Ee -> Ew.0Ee for w > 0
   }
   int flags{0};
DataEdit RealOutputEditing<KIND>::EditForGOutput(DataEdit edit) {
   }
   if (edit.digits.has_value()) {
     *edit.digits = std::max(0, *edit.digits - expo);
   }
   return edit;
 }
 
 // 13.10.4 in F'2018
-template <int binaryPrecision>
-bool RealOutputEditing<binaryPrecision>::EditListDirectedOutput(
-    const DataEdit &edit) {
+template <int KIND>
+bool RealOutputEditing<KIND>::EditListDirectedOutput(const DataEdit &edit) {
   decimal::ConversionToDecimalResult converted{Convert(1, edit.modes.round)};
   if (IsInfOrNaN(converted)) {
     return EditEorDOutput(edit);
   }
   int expo{converted.decimalExponent};
   // The decimal precision of 16-bit floating-point types is very low,
   // so use a reasonable cap of 6 to allow more values to be emitted
   // with Fw.d editing.
   static constexpr int maxExpo{
       std::max(6, BinaryFloatingPoint::decimalPrecision)};
   if (expo < 0 || expo > maxExpo) {
     DataEdit copy{edit};
     copy.modes.scale = 1; // 1P
     return EditEorDOutput(copy);
   }
   return EditFOutput(edit);
 }
 
 // 13.7.5.2.6 in F'2018
-template <int binaryPrecision>
-bool RealOutputEditing<binaryPrecision>::EditEXOutput(const DataEdit &) {
+template <int KIND>
+bool RealOutputEditing<KIND>::EditEXOutput(const DataEdit &) {
   io_.GetIoErrorHandler().Crash(
       "not yet implemented: EX output editing"); // TODO
 }
 
 template <int KIND> bool RealOutputEditing<KIND>::Edit(const DataEdit &edit) {
   switch (edit.descriptor) {
   case 'D':
     return EditEorDOutput(edit);