[flang][runtime] Catch input error case of missing integer value

[klausler]

Summary

Formatted input allows for an empty numeric input field, which
signifies a zero value, but list-directed and NAMELIST input does
not -- apart from the special case of a NAMELIST array.

flang/runtime/edit-input.cpp

static bool ScanNumericPrefix(IoStatementState &io, const DataEdit &edit,
   return negative;
 }
 
 bool EditIntegerInput(
     IoStatementState &io, const DataEdit &edit, void *n, int kind) {
   RUNTIME_CHECK(io.GetIoErrorHandler(), kind >= 1 && !(kind & (kind - 1)));
   switch (edit.descriptor) {
   case DataEdit::ListDirected:
-    if (IsNamelistName(io)) {
+    if (IsNamelistNameOrSlash(io)) {
       return false;
     }
     break;
   case 'G':
   case 'I':
     break;
   case 'B':
     return EditBOZInput<1>(io, edit, n, kind);
for (; next; next = io.NextInField(remaining, edit)) {
     static constexpr int maxLastDigit{
         static_cast<int>(maxu128 - (maxu128OverTen * 10))};
     overflow |= value >= maxu128OverTen &&
         (value > maxu128OverTen || digit > maxLastDigit);
     value *= 10;
     value += digit;
     any = true;
   }
+  if (!any && !remaining) {
+    io.GetIoErrorHandler().SignalError(
+        "Integer value absent from NAMELIST or list-directed input");
+    return false;
+  }
   auto maxForKind{common::UnsignedInt128{1} << ((8 * kind) - 1)};
   overflow |= value >= maxForKind && (value > maxForKind || !negate);
   if (overflow) {
     io.GetIoErrorHandler().SignalError(IostatIntegerInputOverflow,
         "Decimal input overflows INTEGER(%d) variable", kind);
     return false;
   }
   if (negate) {
bool EditCommonRealInput(IoStatementState &io, const DataEdit &edit, void *n) {
   }
   return true;
 }
 
 template <int KIND>
 bool EditRealInput(IoStatementState &io, const DataEdit &edit, void *n) {
   switch (edit.descriptor) {
   case DataEdit::ListDirected:
-    if (IsNamelistName(io)) {
+    if (IsNamelistNameOrSlash(io)) {
       return false;
     }
     return EditCommonRealInput<KIND>(io, edit, n);
   case DataEdit::ListDirectedRealPart:
   case DataEdit::ListDirectedImaginaryPart:
   case 'F':
   case 'E': // incl. EN, ES, & EX
   case 'D':
default:
     return false;
   }
 }
 
 // 13.7.3 in Fortran 2018
 bool EditLogicalInput(IoStatementState &io, const DataEdit &edit, bool &x) {
   switch (edit.descriptor) {
   case DataEdit::ListDirected:
-    if (IsNamelistName(io)) {
+    if (IsNamelistNameOrSlash(io)) {
       return false;
     }
     break;
   case 'L':
   case 'G':
     break;
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInFormat,

 static bool EditListDirectedCharacterInput(
     IoStatementState &io, CHAR *x, std::size_t length, const DataEdit &edit) {
   std::size_t byteCount{0};
   auto ch{io.GetCurrentChar(byteCount)};
   if (ch && (*ch == '\'' || *ch == '"')) {
     io.HandleRelativePosition(byteCount);
     return EditDelimitedCharacterInput(io, x, length, *ch);
   }
-  if (IsNamelistName(io) || io.GetConnectionState().IsAtEOF()) {
+  if (IsNamelistNameOrSlash(io) || io.GetConnectionState().IsAtEOF()) {
     return false;
   }
   // Undelimited list-directed character input: stop at a value separator
   // or the end of the current record.  Subtlety: the "remaining" count
   // here is a dummy that's used to avoid the interpretation of separators
   // in NextInField.
   std::optional<int> remaining{length > 0 ? maxUTF8Bytes : 0};
   while (std::optional<char32_t> next{io.NextInField(remaining, edit)}) {

flang/runtime/namelist.h

struct Item {
     const char *name; // NUL-terminated lower-case
     const Descriptor &descriptor;
   };
   const char *groupName; // NUL-terminated lower-case
   std::size_t items;
   const Item *item; // in original declaration order
 };
 
-// Look ahead on input for an identifier followed by a '=', '(', or '%'
+// Look ahead on input for a '/' or an identifier followed by a '=', '(', or '%'
 // character; for use in disambiguating a name-like value (e.g. F or T) from a
-// NAMELIST group item name.  Always false when not reading a NAMELIST.
-bool IsNamelistName(IoStatementState &);
+// NAMELIST group item name and for coping with short arrays.  Always false
+// when not reading a NAMELIST.
+bool IsNamelistNameOrSlash(IoStatementState &);
 
 } // namespace Fortran::runtime::io
 #endif // FORTRAN_RUNTIME_NAMELIST_H_

flang/runtime/namelist.cpp

if (!next || *next != '/') {
     handler.SignalError(
         "No '/' found after NAMELIST group '%s'", group.groupName);
     return false;
   }
   io.HandleRelativePosition(byteCount);
   return true;
 }
 
-bool IsNamelistName(IoStatementState &io) {
+bool IsNamelistNameOrSlash(IoStatementState &io) {
   if (auto *listInput{
           io.get_if<ListDirectedStatementState<Direction::Input>>()}) {
     if (listInput->inNamelistArray()) {
       SavedPosition savedPosition{io};
       std::size_t byteCount{0};
       if (auto ch{io.GetNextNonBlank(byteCount)}) {
         if (IsLegalIdStart(*ch)) {
           do {
             io.HandleRelativePosition(byteCount);
             ch = io.GetCurrentChar(byteCount);
           } while (ch && IsLegalIdChar(*ch));
           ch = io.GetNextNonBlank(byteCount);
           // TODO: how to deal with NaN(...) ambiguity?
           return ch && (*ch == '=' || *ch == '(' || *ch == '%');
+        } else {
+          return *ch == '/';
         }
       }
     }
   }
   return false;
 }
 
 } // namespace Fortran::runtime::io