[flang][runtime] Fix edge-case FP input bugs

[klausler]

Summary

Blanks are allowed in more places than I allowed for, and
"NAN(foobar)" is allowed to have any parenthesis-balanced
characters in parentheses.

[klausler]

Update: Fix up old sanity test, then avoid usage of "limit" when null.

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

if (ParseNumber(p, inexact, limit)) {
     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 (toupper(p[0]) == 'N' && toupper(p[1]) == 'A' && toupper(p[2]) == 'N') {
+    if ((!limit || limit >= p + 3) && toupper(p[0]) == 'N' &&
+        toupper(p[1]) == 'A' && toupper(p[2]) == 'N') {
       // NaN
       p += 3;
+      if ((!limit || p < limit) && *p == '(') {
+        int depth{1};
+        do {
+          ++p;
+          if (limit && p >= limit) {
+            // Invalid input
+            return {Real{NaN()}, Invalid};
+          } else if (*p == '(') {
+            ++depth;
+          } else if (*p == ')') {
+            --depth;
+          }
+        } 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 (*q == '-' || *q == '+') {
+        if (isNegative_ || *q == '+') {
           ++q;
         }
-      if (toupper(q[0]) == 'I' && toupper(q[1]) == 'N' &&
-          toupper(q[2]) == 'F') {
+      }
+      if ((!limit || limit >= q + 3) && toupper(q[0]) == 'I' &&
+          toupper(q[1]) == 'N' && toupper(q[2]) == 'F') {
         p = q + 3;
         return {Real{Infinity()}};
       } else {
         // Invalid input
         return {Real{NaN()}, Invalid};
       }
     }
   }

flang/runtime/edit-input.cpp

for (; next &&
          next = io.NextInField(remaining, edit)) {
       if (*next >= 'a' && *next <= 'z') {
         Put(*next - 'a' + 'A');
       } else {
         Put(*next);
       }
     }
     if (next && *next == '(') { // NaN(...)
-      while (next && *next != ')') {
+      Put('(');
+      int depth{1};
+      do {
         next = io.NextInField(remaining, edit);
+        if (!next) {
+          break;
+        } else if (*next == '(') {
+          ++depth;
+        } else if (*next == ')') {
+          --depth;
         }
+        Put(*next);
+      } while (depth > 0);
     }
     exponent = 0;
   } else if (first == decimal || (first >= '0' && first <= '9') ||
       (bzMode && (first == ' ' || first == '\t')) || first == 'E' ||
       first == 'D' || first == 'Q') {
     Put('.'); // input field is normalized to a fraction
     auto start{got};
     for (; next; next = io.NextInField(remaining, edit)) {
if (next &&
       io.SkipSpaces(remaining);
       next = io.NextInField(remaining, edit);
     }
     // The default exponent is -kP, but the scale factor doesn't affect
     // an explicit exponent.
     exponent = -edit.modes.scale;
     if (next &&
         (*next == '-' || *next == '+' || (*next >= '0' && *next <= '9') ||
-            (bzMode && (*next == ' ' || *next == '\t')))) {
+            *next == ' ' || *next == '\t')) {
       bool negExpo{*next == '-'};
       if (negExpo || *next == '+') {
         next = io.NextInField(remaining, edit);
       }
       for (exponent = 0; next; next = io.NextInField(remaining, edit)) {
         if (*next >= '0' && *next <= '9') {
           exponent = 10 * exponent + *next - '0';
-        } else if (bzMode && (*next == ' ' || *next == '\t')) {
+        } else if (*next == ' ' || *next == '\t') {
+          if (bzMode) {
             exponent = 10 * exponent;
+          }
         } else {
           break;
         }
       }
       if (negExpo) {
         exponent = -exponent;
       }
     }
static bool TryFastPathRealInput(
   std::int64_t maxConsume{
       std::min<std::int64_t>(got, edit.width.value_or(got))};
   const char *limit{str + maxConsume};
   decimal::ConversionToBinaryResult<PRECISION> converted{
       decimal::ConvertToBinary<PRECISION>(p, edit.modes.round, limit)};
   if (converted.flags & decimal::Invalid) {
     return false;
   }
-  if (edit.digits.value_or(0) != 0 &&
-      std::memchr(str, '.', p - str) == nullptr) {
-    // No explicit decimal point, and edit descriptor is Fw.d (or other)
-    // with d != 0, which implies scaling.
+  if (edit.digits.value_or(0) != 0) {
+    // Edit descriptor is Fw.d (or other) with d != 0, which
+    // implies scaling
+    const char *q{str};
+    for (; q < limit; ++q) {
+      if (*q == '.' || *q == 'n' || *q == 'N') {
+        break;
+      }
+    }
+    if (q == limit) {
+      // No explicit decimal point, and not NaN/Inf.
       return false;
     }
+  }
   for (; p < limit && (*p == ' ' || *p == '\t'); ++p) {
   }
   if (edit.descriptor == DataEdit::ListDirectedImaginaryPart) {
     // Need to consume a trailing ')' and any white space after
     if (p >= limit || *p != ')') {
       return false;
     }
     for (++p; p < limit && (*p == ' ' || *p == '\t'); ++p) {
bool EditCommonRealInput(IoStatementState &io, const DataEdit &edit, void *n) {
   buffer[got] = '\0';
   const char *p{buffer};
   decimal::ConversionToBinaryResult<binaryPrecision> converted{
       decimal::ConvertToBinary<binaryPrecision>(p, edit.modes.round)};
   if (hadExtra) {
     converted.flags = static_cast<enum decimal::ConversionResultFlags>(
         converted.flags | decimal::Inexact);
   }
+  if (*p) { // unprocessed junk after value
+    io.GetIoErrorHandler().SignalError(IostatBadRealInput);
+    return false;
+  }
   *reinterpret_cast<decimal::BinaryFloatingPointNumber<binaryPrecision> *>(n) =
       converted.binary;
   // Set FP exception flags
   if (converted.flags != decimal::ConversionResultFlags::Exact) {
     RaiseFPExceptions(converted.flags);
   }
   return true;
 }

flang/unittests/Decimal/quick-sanity-test.cpp

if (q >= buffer && q < buffer + sizeof buffer) {
       std::sprintf(q + result.length, "e%d", expo);
     }
     const char *p{q};
     auto rflags{ConvertDecimalToFloat(&p, &y, RoundNearest)};
     union u u;
     if (!(x == x)) {
       if (y == y || *p != '\0' || (rflags & Invalid)) {
         u.x = y;
-        failed(x) << " (NaN) " << flags << ": -> '" << result.str << "' -> 0x";
-        failed(x).write_hex(u.u) << " '" << p << "' " << rflags << '\n';
+        (failed(x) << " (NaN) " << flags << ": -> '" << result.str << "' -> 0x")
+                .write_hex(u.u)
+            << " '" << p << "' " << rflags << '\n';
       }
     } else if (x != y || *p != '\0' || (rflags & Invalid)) {
-      u.x = y;
-      failed(x) << ' ' << flags << ": -> '" << result.str << "' -> 0x";
-      failed(x).write_hex(u.u) << " '" << p << "' " << rflags << '\n';
+      u.x = x;
+      (failed(x) << ' ' << flags << ": -> '" << result.str << "' -> 0x")
+              .write_hex(u.u)
+          << " '" << p << "' " << rflags << '\n';
     }
   }
 }
 
 int main() {
   union u u;
   testDirect(-1.0, "-1", 1);
   testDirect(0.0, "0", 0);