[flang][runtime] Fix overflow detection for REAL input

[klausler]

Summary

The test for an overflow during decimal->binary conversion was taking
place too late, causing the data not to be rescanned from the beginning.

flang/runtime/edit-input.cpp

if (next &&
         (*next == '-' || *next == '+' || (*next >= '0' && *next <= '9') ||
             *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') {
+          if (exponent < 10000) {
             exponent = 10 * exponent + *next - '0';
+          }
         } else if (*next == ' ' || *next == '\t') {
           if (bzMode) {
             exponent = 10 * exponent;
           }
         } else {
           break;
         }
       }
if (got == 0 || str == nullptr ||
     return false; // could not access reliably-terminated input stream
   }
   const char *p{str};
   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) {
+  if (converted.flags & (decimal::Invalid | decimal::Overflow)) {
     return false;
   }
   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') {
if (edit.width && p < str + *edit.width) {
     return false; // unconverted characters remain in fixed width field
   }
   // Success on the fast path!
   *reinterpret_cast<decimal::BinaryFloatingPointNumber<PRECISION> *>(n) =
       converted.binary;
   io.HandleRelativePosition(p - str);
   // Set FP exception flags
   if (converted.flags != decimal::ConversionResultFlags::Exact) {
-    if (converted.flags & decimal::ConversionResultFlags::Overflow) {
-      return false; // let slow path deal with it
-    }
     RaiseFPExceptions(converted.flags);
   }
   return true;
 }
 
 template <int KIND>
 bool EditCommonRealInput(IoStatementState &io, const DataEdit &edit, void *n) {
   constexpr int binaryPrecision{common::PrecisionOfRealKind(KIND)};

flang/runtime/io-stmt.h

public:
   bool EmitField(const char *, std::size_t length, std::size_t width);
 
   // For fixed-width fields, initialize the number of remaining characters.
   // Skip over leading blanks, then return the first non-blank character (if
   // any).
   std::optional<char32_t> PrepareInput(
       const DataEdit &edit, std::optional<int> &remaining) {
     remaining.reset();
-    if (edit.descriptor == DataEdit::ListDirected) {
+    if (edit.IsListDirected()) {
       std::size_t byteCount{0};
       GetNextNonBlank(byteCount);
     } else {
       if (edit.width.value_or(0) > 0) {
         remaining = *edit.width;
       }
       SkipSpaces(remaining);
     }