[flang] Signal runtime error on WRITE after ENDFILE

[klausler]

Summary

After an ENDFILE statement, a WRITE is an error without
a prior BACKSPACE. Also fix the return value for the case
of formatted integer input with no input digits to be false
(exposed by new test).

flang/include/flang/Runtime/iostat.h

enum Iostat {
   IostatOpenBadRecl,
   IostatOpenUnknownSize,
   IostatOpenBadAppend,
   IostatWriteToReadOnly,
   IostatReadFromWriteOnly,
   IostatBackspaceNonSequential,
   IostatBackspaceAtFirstRecord,
   IostatRewindNonSequential,
+  IostatWriteAfterEndfile,
 };
 
 const char *IostatErrorString(int);
 
 } // namespace Fortran::runtime::io
 #endif // FORTRAN_RUNTIME_IOSTAT_H_

flang/runtime/connection.h

struct ConnectionAttributes {
   Access access{Access::Sequential}; // ACCESS='SEQUENTIAL', 'DIRECT', 'STREAM'
   std::optional<bool> isUnformatted; // FORM='UNFORMATTED' if true
   bool isUTF8{false}; // ENCODING='UTF-8'
   std::optional<std::int64_t> openRecl; // RECL= on OPEN
 };
 
 struct ConnectionState : public ConnectionAttributes {
   bool IsAtEOF() const; // true when read has hit EOF or endfile record
+  bool IsAfterEndfile() const; // true after ENDFILE until repositioned
   std::size_t RemainingSpaceInRecord() const;
   bool NeedAdvance(std::size_t) const;
   void HandleAbsolutePosition(std::int64_t);
   void HandleRelativePosition(std::int64_t);
 
   void BeginRecord() {
     positionInRecord = 0;
     furthestPositionInRecord = 0;

flang/runtime/connection.cpp

 bool ConnectionState::NeedAdvance(std::size_t width) const {
   return positionInRecord > 0 && width > RemainingSpaceInRecord();
 }
 
 bool ConnectionState::IsAtEOF() const {
   return endfileRecordNumber && currentRecordNumber >= *endfileRecordNumber;
 }
 
+bool ConnectionState::IsAfterEndfile() const {
+  return endfileRecordNumber && currentRecordNumber > *endfileRecordNumber;
+}
+
 void ConnectionState::HandleAbsolutePosition(std::int64_t n) {
   positionInRecord = std::max(n, std::int64_t{0}) + leftTabLimit.value_or(0);
 }
 
 void ConnectionState::HandleRelativePosition(std::int64_t n) {
   positionInRecord = std::max(leftTabLimit.value_or(0), positionInRecord + n);
 }
 

flang/runtime/edit-input.cpp

io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
         "Data edit descriptor '%c' may not be used with an INTEGER data item",
         edit.descriptor);
     return false;
   }
   std::optional<int> remaining;
   std::optional<char32_t> next;
   bool negate{ScanNumericPrefix(io, edit, next, remaining)};
   common::UnsignedInt128 value;
+  bool any{false};
   for (; next; next = io.NextInField(remaining)) {
     char32_t ch{*next};
     if (ch == ' ' || ch == '\t') {
       if (edit.modes.editingFlags & blankZero) {
         ch = '0'; // BZ mode - treat blank as if it were zero
       } else {
         continue;
       }
     }
     int digit{0};
     if (ch >= '0' && ch <= '9') {
       digit = ch - '0';
     } else {
       io.GetIoErrorHandler().SignalError(
           "Bad character '%lc' in INTEGER input field", ch);
       return false;
     }
     value *= 10;
     value += digit;
+    any = true;
   }
+  if (any) {
     if (negate) {
       value = -value;
     }
     std::memcpy(n, &value, kind);
-  return true;
+  }
+  return any;
 }
 
 // Parses a REAL input number from the input source as a normalized
 // fraction into a supplied buffer -- there's an optional '-', a
 // decimal point, and at least one digit.  The adjusted exponent value
 // is returned in a reference argument.  The returned value is the number
 // of characters that (should) have been written to the buffer -- this can
 // be larger than the buffer size and can indicate overflow.  Replaces

flang/runtime/iostat.cpp

const char *IostatErrorString(int iostat) {
   case IostatReadFromWriteOnly:
     return "Attempted input from write-only file";
   case IostatBackspaceNonSequential:
     return "BACKSPACE on non-sequential file";
   case IostatBackspaceAtFirstRecord:
     return "BACKSPACE at first record";
   case IostatRewindNonSequential:
     return "REWIND on non-sequential file";
+  case IostatWriteAfterEndfile:
+    return "WRITE after ENDFILE";
   default:
     return nullptr;
   }
 }
 
 } // namespace Fortran::runtime::io

flang/runtime/unit.cpp

if (openRecl) {
     }
   } else if (recordLength) {
     // It is possible for recordLength to have a value now for a
     // variable-length output record if the previous operation
     // was a BACKSPACE or non advancing input statement.
     recordLength.reset();
     beganReadingRecord_ = false;
   }
+  if (IsAfterEndfile()) {
+    handler.SignalError(IostatWriteAfterEndfile);
+    return false;
+  }
   WriteFrame(frameOffsetInFile_, recordOffsetInFrame_ + furthestAfter, handler);
   if (positionInRecord > furthestPositionInRecord) {
     std::memset(Frame() + recordOffsetInFrame_ + furthestPositionInRecord, ' ',
         positionInRecord - furthestPositionInRecord);
   }
   char *to{Frame() + recordOffsetInFrame_ + positionInRecord};
   std::memcpy(to, data, bytes);
   if (swapEndianness_) {
if (access == Access::Direct) {
       if (got >= need) {
         recordLength = openRecl;
       } else {
         recordLength.reset();
         handler.SignalEnd();
       }
     } else if (access == Access::Sequential) {
       recordLength.reset();
-      if (endfileRecordNumber && currentRecordNumber >= *endfileRecordNumber) {
+      if (IsAtEOF()) {
         handler.SignalEnd();
       } else {
         RUNTIME_CHECK(handler, isUnformatted.has_value());
         if (isUnformatted.value_or(false)) {
           BeginSequentialVariableUnformattedInputRecord(handler);
         } else { // formatted
           BeginSequentialVariableFormattedInputRecord(handler);
         }
if (!(openRecl && access == Access::Direct)) {
         ok = ok &&
             Emit(reinterpret_cast<const char *>(&length), sizeof length,
                 sizeof length, handler);
       } else {
         // Terminate formatted variable length record
         ok = ok && Emit("\n", 1, 1, handler); // TODO: Windows CR+LF
       }
     }
+    if (IsAfterEndfile()) {
+      return false;
+    }
     CommitWrites();
     impliedEndfile_ = true;
     ++currentRecordNumber;
-    if (endfileRecordNumber && currentRecordNumber >= *endfileRecordNumber) {
+    if (IsAtEOF()) {
       endfileRecordNumber.reset();
     }
     return ok;
   }
 }
 
 void ExternalFileUnit::BackspaceRecord(IoErrorHandler &handler) {
   if (access != Access::Sequential) {
     handler.SignalError(IostatBackspaceNonSequential,
         "BACKSPACE(UNIT=%d) on non-sequential file", unitNumber());
   } else {
-    if (endfileRecordNumber && currentRecordNumber > *endfileRecordNumber) {
+    if (IsAfterEndfile()) {
       // BACKSPACE after explicit ENDFILE
       currentRecordNumber = *endfileRecordNumber;
     } else {
       DoImpliedEndfile(handler);
       if (frameOffsetInFile_ + recordOffsetInFrame_ > 0) {
         --currentRecordNumber;
         if (openRecl && access == Access::Direct) {
           BackspaceFixedRecord(handler);

 
 void ExternalFileUnit::Endfile(IoErrorHandler &handler) {
   if (access != Access::Sequential) {
     handler.SignalError(IostatEndfileNonSequential,
         "ENDFILE(UNIT=%d) on non-sequential file", unitNumber());
   } else if (!mayWrite()) {
     handler.SignalError(IostatEndfileUnwritable,
         "ENDFILE(UNIT=%d) on read-only file", unitNumber());
-  } else if (endfileRecordNumber &&
-      currentRecordNumber > *endfileRecordNumber) {
+  } else if (IsAfterEndfile()) {
     // ENDFILE after ENDFILE
   } else {
     DoEndfile(handler);
     // Explicit ENDFILE leaves position *after* the endfile record
     RUNTIME_CHECK(handler, endfileRecordNumber.has_value());
     currentRecordNumber = *endfileRecordNumber + 1;
   }
 }

flang/unittests/Runtime/ExternalIOTest.cpp

ASSERT_TRUE(
       IONAME(InputAscii)(io, resultRecord.data(), resultRecord.length()))
       << "InputAscii() ";
   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
       << "EndIoStatement() for Read ";
 
   ASSERT_EQ(resultRecord, expectedRecord)
       << "Record after non advancing read followed by wrote";
 }
+
+TEST(ExternalIOTests, TestWriteAfterEndfile) {
+  // OPEN(NEWUNIT=unit,ACCESS='SEQUENTIAL',ACTION='READWRITE',&
+  //   FORM='FORMATTED',STATUS='SCRATCH')
+  auto *io{IONAME(BeginOpenNewUnit)(__FILE__, __LINE__)};
+  ASSERT_TRUE(IONAME(SetAccess)(io, "SEQUENTIAL", 10))
+      << "SetAccess(SEQUENTIAL)";
+  ASSERT_TRUE(IONAME(SetAction)(io, "READWRITE", 9)) << "SetAction(READWRITE)";
+  ASSERT_TRUE(IONAME(SetForm)(io, "FORMATTED", 9)) << "SetForm(FORMATTED)";
+  ASSERT_TRUE(IONAME(SetStatus)(io, "SCRATCH", 7)) << "SetStatus(SCRATCH)";
+  int unit{-1};
+  ASSERT_TRUE(IONAME(GetNewUnit)(io, unit)) << "GetNewUnit()";
+  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+      << "EndIoStatement() for OpenNewUnit";
+  // WRITE(unit,"(I8)") 1234
+  static constexpr std::string_view format{"(I8)"};
+  io = IONAME(BeginExternalFormattedOutput)(
+      format.data(), format.length(), unit, __FILE__, __LINE__);
+  ASSERT_TRUE(IONAME(OutputInteger64)(io, 1234)) << "OutputInteger64()";
+  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+      << "EndIoStatement for WRITE before ENDFILE";
+  // ENDFILE(unit)
+  io = IONAME(BeginEndfile)(unit, __FILE__, __LINE__);
+  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+      << "EndIoStatement for ENDFILE";
+  // WRITE(unit,"(I8)",iostat=iostat) 5678
+  io = IONAME(BeginExternalFormattedOutput)(
+      format.data(), format.length(), unit, __FILE__, __LINE__);
+  IONAME(EnableHandlers)(io, true /*IOSTAT=*/);
+  ASSERT_FALSE(IONAME(OutputInteger64)(io, 5678)) << "OutputInteger64()";
+  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatWriteAfterEndfile)
+      << "EndIoStatement for WRITE after ENDFILE";
+  // BACKSPACE(unit)
+  io = IONAME(BeginBackspace)(unit, __FILE__, __LINE__);
+  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+      << "EndIoStatement for BACKSPACE";
+  // WRITE(unit,"(I8)") 3456
+  io = IONAME(BeginExternalFormattedOutput)(
+      format.data(), format.length(), unit, __FILE__, __LINE__);
+  ASSERT_TRUE(IONAME(OutputInteger64)(io, 3456)) << "OutputInteger64()";
+  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+      << "EndIoStatement for WRITE after BACKSPACE";
+  // REWIND(unit)
+  io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
+  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+      << "EndIoStatement for REWIND";
+  // READ(unit,"(I8)",END=) j, k
+  std::int64_t j{-1}, k{-1}, eof{-1};
+  io = IONAME(BeginExternalFormattedInput)(
+      format.data(), format.length(), unit, __FILE__, __LINE__);
+  IONAME(EnableHandlers)(io, false, false, true /*END=*/);
+  ASSERT_TRUE(IONAME(InputInteger)(io, j)) << "InputInteger(j)";
+  ASSERT_EQ(j, 1234) << "READ(j)";
+  ASSERT_TRUE(IONAME(InputInteger)(io, k)) << "InputInteger(k)";
+  ASSERT_EQ(k, 3456) << "READ(k)";
+  ASSERT_FALSE(IONAME(InputInteger)(io, eof)) << "InputInteger(eof)";
+  ASSERT_EQ(eof, -1) << "READ(eof)";
+  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatEnd) << "EndIoStatement for READ";
+}