[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

   IostatBackspaceNonSequential,
   IostatBackspaceAtFirstRecord,
   IostatRewindNonSequential,
+  IostatWriteAfterEndfile,
 };
 
 const char *IostatErrorString(int);

flang/runtime/connection.h

 
 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);

flang/runtime/connection.cpp

   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);
 }

flang/runtime/edit-input.cpp

   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') {

     }
     value *= 10;
     value += digit;
+    any = true;
   }
-  if (negate) {
-    value = -value;
+  if (any) {
+    if (negate) {
+      value = -value;
+    }
+    std::memcpy(n, &value, kind);
   }
-  std::memcpy(n, &value, kind);
-  return true;
+  return any;
 }
 
 // Parses a REAL input number from the input source as a normalized

flang/runtime/iostat.cpp

     return "BACKSPACE at first record";
   case IostatRewindNonSequential:
     return "REWIND on non-sequential file";
+  case IostatWriteAfterEndfile:
+    return "WRITE after ENDFILE";
   default:
     return nullptr;
   }

flang/runtime/unit.cpp

     recordLength.reset();
     beganReadingRecord_ = false;
   }
+  if (IsAfterEndfile()) {
+    handler.SignalError(IostatWriteAfterEndfile);
+    return false;
+  }
   WriteFrame(frameOffsetInFile_, recordOffsetInFrame_ + furthestAfter, handler);
   if (positionInRecord > furthestPositionInRecord) {
     std::memset(Frame() + recordOffsetInFrame_ + furthestPositionInRecord, ' ',

       }
     } else if (access == Access::Sequential) {
       recordLength.reset();
-      if (endfileRecordNumber && currentRecordNumber >= *endfileRecordNumber) {
+      if (IsAtEOF()) {
         handler.SignalEnd();
       } else {
         RUNTIME_CHECK(handler, isUnformatted.has_value());

         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;

     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 {

   } 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);

flang/unittests/Runtime/ExternalIOTest.cpp

   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";
+}