[flang][runtime] Correct emission & reading of unterminated final records

[klausler]

Summary

When the last operation on a foramtted sequential or stream file (prior
to an implied or explicit ENDFILE) is a non-advancing WRITE, ensure
that any partial record data is emitted to the file without a line
terminator. Further, when that last record is read with a non-advancing
READ, ensure that it won't raise an end-of-record condition after its
data, but instead will signal an end-of-file.

flang/runtime/connection.h

struct ConnectionState : public ConnectionAttributes {
   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;
+    unterminatedRecord = false;
   }
 
   std::optional<std::int64_t> EffectiveRecordLength() const {
     // When an input record is longer than an explicit RECL= from OPEN
     // it is effectively truncated on input.
     return openRecl && recordLength && *openRecl < *recordLength ? openRecl
                                                                  : recordLength;
   }
struct ConnectionState : public ConnectionAttributes {
   // Mutable modes set at OPEN() that can be overridden in READ/WRITE & FORMAT
   MutableModes modes; // BLANK=, DECIMAL=, SIGN=, ROUND=, PAD=, DELIM=, kP
 
   // Set when processing repeated items during list-directed & NAMELIST input
   // in order to keep a span of records in frame on a non-positionable file,
   // so that backspacing to the beginning of the repeated item doesn't require
   // repositioning the external storage medium when that's impossible.
   bool pinnedFrame{false};
+
+  // Set when the last record of a file is not properly terminated
+  // so that a non-advancing READ will not signal EOR.
+  bool unterminatedRecord{false};
 };
 
 // Utility class for capturing and restoring a position in an input stream.
 class SavedPosition {
 public:
   explicit SavedPosition(IoStatementState &);
   ~SavedPosition();
 
 private:
   IoStatementState &io_;
   ConnectionState saved_;
 };
 
 } // namespace Fortran::runtime::io
 #endif // FORTRAN_RUNTIME_IO_CONNECTION_H_

flang/runtime/io-stmt.cpp

if constexpr (DIR == Direction::Input) {
     if (mutableModes().nonAdvancing) {
       // Make effects of positioning past the last Emit() visible with blanks.
       std::int64_t n{unit().positionInRecord - unit().furthestPositionInRecord};
       unit().positionInRecord = unit().furthestPositionInRecord;
       while (n-- > 0 && unit().Emit(" ", 1, 1, *this)) {
       }
       unit().leftTabLimit = unit().furthestPositionInRecord;
     } else {
-      unit().leftTabLimit.reset();
       unit().AdvanceRecord(*this);
     }
     unit().FlushIfTerminal(*this);
   }
   return IoStatementBase::CompleteOperation();
 }
 
 template <Direction DIR> int ExternalIoStatementState<DIR>::EndIoStatement() {

 
 bool IoStatementState::CheckForEndOfRecord() {
   const ConnectionState &connection{GetConnectionState()};
   if (!connection.IsAtEOF()) {
     if (auto length{connection.EffectiveRecordLength()}) {
       if (connection.positionInRecord >= *length) {
         IoErrorHandler &handler{GetIoErrorHandler()};
         if (mutableModes().nonAdvancing) {
+          if (connection.access == Access::Stream &&
+              connection.unterminatedRecord) {
+            // Reading final unterminated record left by a
+            // non-advancing WRITE on a stream file prior to
+            // positioning or ENDFILE.
+            handler.SignalEnd();
+          } else {
             handler.SignalEor();
+          }
         } else if (!connection.modes.pad) {
           handler.SignalError(IostatRecordReadOverrun);
         }
         return connection.modes.pad; // PAD='YES'
       }
     }
   }
   return false;

flang/runtime/unit.cpp

if (got >= need) {
     if (swapEndianness_) {
       SwapEndianness(data, bytes, elementBytes);
     }
     positionInRecord += bytes;
     furthestPositionInRecord = furthestAfter;
     return true;
   } else {
     handler.SignalEnd();
-    if (access == Access::Sequential) {
+    if (IsRecordFile() && access != Access::Direct) {
       endfileRecordNumber = currentRecordNumber;
     }
     return false;
   }
 }
 
 std::size_t ExternalFileUnit::GetNextInputBytes(
     const char *&p, IoErrorHandler &handler) {
if (static_cast<std::int64_t>(positionInRecord + bytes) <=
     auto at{recordOffsetInFrame_ + positionInRecord};
     auto need{static_cast<std::size_t>(at + bytes)};
     auto got{ReadFrame(frameOffsetInFile_, need, handler)};
     SetVariableFormattedRecordLength();
     if (got >= need) {
       return Frame() + at;
     }
     handler.SignalEnd();
-    if (access == Access::Sequential) {
+    if (IsRecordFile() && access != Access::Direct) {
       endfileRecordNumber = currentRecordNumber;
     }
   }
   return nullptr;
 }
 
 bool ExternalFileUnit::SetVariableFormattedRecordLength() {
   if (recordLength || access == Access::Direct) {

 #ifdef _WIN32
       if (!isWindowsTextFile()) {
         lineEnding = "\r\n";
         lineEndingBytes = 2;
       }
 #endif
       ok = ok && Emit(lineEnding, lineEndingBytes, 1, handler);
     }
+    leftTabLimit.reset();
     if (IsAfterEndfile()) {
       return false;
     }
     CommitWrites();
     ++currentRecordNumber;
     if (access != Access::Direct) {
       impliedEndfile_ = IsRecordFile();
       if (IsAtEOF()) {
handler.SignalError(IostatEndfileDirect,
         "ENDFILE(UNIT=%d) on direct-access file", unitNumber());
   } else if (!mayWrite()) {
     handler.SignalError(IostatEndfileUnwritable,
         "ENDFILE(UNIT=%d) on read-only file", unitNumber());
   } else if (IsAfterEndfile()) {
     // ENDFILE after ENDFILE
   } else {
     DoEndfile(handler);
-    if (access == Access::Sequential) {
+    if (IsRecordFile() && access != Access::Direct) {
       // Explicit ENDFILE leaves position *after* the endfile record
       RUNTIME_CHECK(handler, endfileRecordNumber.has_value());
       currentRecordNumber = *endfileRecordNumber + 1;
     }
   }
 }
 
 void ExternalFileUnit::Rewind(IoErrorHandler &handler) {
do {
     std::size_t need{length + 1};
     length =
         ReadFrame(frameOffsetInFile_, recordOffsetInFrame_ + need, handler) -
         recordOffsetInFrame_;
     if (length < need) {
       if (length > 0) {
         // final record w/o \n
         recordLength = length;
+        unterminatedRecord = true;
       } else {
         handler.SignalEnd();
       }
       break;
     }
   } while (!SetVariableFormattedRecordLength());
 }
 
if (impliedEndfile_) {
     impliedEndfile_ = false;
     if (access != Access::Direct && IsRecordFile() && mayPosition()) {
       DoEndfile(handler);
     }
   }
 }
 
 void ExternalFileUnit::DoEndfile(IoErrorHandler &handler) {
-  if (IsRecordFile()) {
+  if (IsRecordFile() && access != Access::Direct) {
+    if (furthestPositionInRecord > 0) {
+      // Last write was non-advancing, so AdvanceRecord() was not called.
+      leftTabLimit.reset();
+      ++currentRecordNumber;
+    }
     endfileRecordNumber = currentRecordNumber;
   }
   FlushOutput(handler);
-  Truncate(frameOffsetInFile_ + recordOffsetInFrame_, handler);
+  Truncate(frameOffsetInFile_ + recordOffsetInFrame_ + furthestPositionInRecord,
+      handler);
   BeginRecord();
   impliedEndfile_ = false;
 }
 
 void ExternalFileUnit::CommitWrites() {
   frameOffsetInFile_ +=
       recordOffsetInFrame_ + recordLength.value_or(furthestPositionInRecord);
   recordOffsetInFrame_ = 0;