[flang] Correct INQUIRE(POSITION= & PAD=)

[klausler]

Summary

INQUIRE(POSITION=)'s results need to reflect the POSITION=
specifier used for the OPEN statement until the unit has been
repositioned. Preserve the POSITION= from OPEN and used it
for INQUIRE(POSITION=) until is becomes obsolete.

INQUIRE(PAD=) is implemented here in the case of an unconnected unit
with Fortran 2018 semantics; i.e., "UNDEFINED", rather than Fortran 90's
"YES"/"NO" (see 4.3.6 para 2). Apparent failures with F'90-only tests
will persist with INQUIRE(PAD=); these discrepancies don't seem to warrant
an option or environment variable.

To make the implementation of INQUIRE more closely match the language
in the standard, rename IsOpen() to IsConnected(), and use it explicitly
for the various INQUIRE specifiers.

flang/runtime/connection.h

 class IoStatementState;
 
 enum class Direction { Output, Input };
 enum class Access { Sequential, Direct, Stream };
 
 inline bool IsRecordFile(Access a) { return a != Access::Stream; }
 
 // These characteristics of a connection are immutable after being
-// established in an OPEN statement.
+// established in an OPEN statement, except for recordLength,
+// which is immutable only when isFixedRecordLength is true.
 struct ConnectionAttributes {
   Access access{Access::Sequential}; // ACCESS='SEQUENTIAL', 'DIRECT', 'STREAM'
   std::optional<bool> isUnformatted; // FORM='UNFORMATTED' if true
   bool isUTF8{false}; // ENCODING='UTF-8'
   bool isFixedRecordLength{false}; // RECL= on OPEN
   std::optional<std::int64_t> recordLength; // RECL= or current record
 };
 

flang/runtime/file.h

public:
   bool mayWrite() const { return mayWrite_; }
   bool mayPosition() const { return mayPosition_; }
   bool mayAsynchronous() const { return mayAsynchronous_; }
   void set_mayAsynchronous(bool yes) { mayAsynchronous_ = yes; }
   FileOffset position() const { return position_; }
   bool isTerminal() const { return isTerminal_; }
   std::optional<FileOffset> knownSize() const { return knownSize_; }
 
-  bool IsOpen() const { return fd_ >= 0; }
+  bool IsConnected() const { return fd_ >= 0; }
   void Open(OpenStatus, std::optional<Action>, Position, IoErrorHandler &);
   void Predefine(int fd);
   void Close(CloseStatus, IoErrorHandler &);
 
   // Reads data into memory; returns amount acquired.  Synchronous.
   // Partial reads (less than minBytes) signify end-of-file.  If the
   // buffer is larger than minBytes, and extra returned data will be
   // preserved for future consumption, set maxBytes larger than minBytes
public:
 
   // Asynchronous transfers
   int ReadAsynchronously(FileOffset, char *, std::size_t, IoErrorHandler &);
   int WriteAsynchronously(
       FileOffset, const char *, std::size_t, IoErrorHandler &);
   void Wait(int id, IoErrorHandler &);
   void WaitAll(IoErrorHandler &);
 
+  // INQUIRE(POSITION=)
+  Position InquirePosition() const;
+
 private:
   struct Pending {
     int id;
     int ioStat{0};
     OwningPtr<Pending> next;
   };
 
   void CheckOpen(const Terminator &);
   bool Seek(FileOffset, IoErrorHandler &);
   bool RawSeek(FileOffset);
   bool RawSeekToEnd();
   int PendingResult(const Terminator &, int);
+  void SetPosition(FileOffset pos) {
+    position_ = pos;
+    openPosition_.reset();
+  }
 
   int fd_{-1};
   OwningPtr<char> path_;
   std::size_t pathLength_;
   bool mayRead_{false};
   bool mayWrite_{false};
   bool mayPosition_{false};
   bool mayAsynchronous_{false};
+  std::optional<Position> openPosition_; // from Open(); reset after positioning
   FileOffset position_{0};
   std::optional<FileOffset> knownSize_;
   bool isTerminal_{false};
 
   int nextId_;
   OwningPtr<Pending> pending_;
 };
 
 bool IsATerminal(int fd);
 bool IsExtant(const char *path);
 bool MayRead(const char *path);
 bool MayWrite(const char *path);
 bool MayReadAndWrite(const char *path);
 } // namespace Fortran::runtime::io
 #endif // FORTRAN_RUNTIME_FILE_H_

flang/runtime/file.cpp

#ifndef _WIN32
     }
 #else // TODO: _WIN32
     mayPosition_ = true;
 #endif
   } else {
     knownSize_ = 0;
     mayPosition_ = true;
   }
+  openPosition_ = position; // for INQUIRE(POSITION=)
 }
 
 void OpenFile::Predefine(int fd) {
   fd_ = fd;
   path_.reset();
   pathLength_ = 0;
   position_ = 0;
   knownSize_.reset();
if (chunk == 0) {
       break;
     } else if (chunk < 0) {
       auto err{errno};
       if (err != EAGAIN && err != EWOULDBLOCK && err != EINTR) {
         handler.SignalError(err);
         break;
       }
     } else {
-      position_ += chunk;
+      SetPosition(position_ + chunk);
       got += chunk;
     }
   }
   return got;
 }
 
 std::size_t OpenFile::Write(FileOffset at, const char *buffer,
     std::size_t bytes, IoErrorHandler &handler) {
   if (bytes == 0) {
     return 0;
   }
   CheckOpen(handler);
   if (!Seek(at, handler)) {
     return 0;
   }
   std::size_t put{0};
   while (put < bytes) {
     auto chunk{::write(fd_, buffer + put, bytes - put)};
     if (chunk >= 0) {
-      position_ += chunk;
+      SetPosition(position_ + chunk);
       put += chunk;
     } else {
       auto err{errno};
       if (err != EAGAIN && err != EWOULDBLOCK && err != EINTR) {
         handler.SignalError(err);
         break;
       }
     }
if (pending_) {
       pending_.reset(pending_->next.release());
     } else {
       return;
     }
     handler.SignalError(ioStat);
   }
 }
 
+Position OpenFile::InquirePosition() const {
+  if (openPosition_) { // from OPEN statement
+    return *openPosition_;
+  } else { // unit has been repositioned since opening
+    if (position_ == knownSize_.value_or(position_ + 1)) {
+      return Position::Append;
+    } else if (position_ == 0 && mayPosition_) {
+      return Position::Rewind;
+    } else {
+      return Position::AsIs; // processor-dependent & no common behavior
+    }
+  }
+}
+
 void OpenFile::CheckOpen(const Terminator &terminator) {
   RUNTIME_CHECK(terminator, fd_ >= 0);
 }
 
 bool OpenFile::Seek(FileOffset at, IoErrorHandler &handler) {
   if (at == position_) {
     return true;
   } else if (RawSeek(at)) {
-    position_ = at;
+    SetPosition(at);
     return true;
   } else {
     handler.SignalErrno();
     return false;
   }
 }
 
 bool OpenFile::RawSeek(FileOffset at) {

flang/runtime/io-stmt.cpp

if (unit().createdForInternalChildIo()) {
     SignalError(IostatInquireInternalUnit,
         "INQUIRE of unit created for defined derived type I/O of an internal "
         "unit");
     return false;
   }
   const char *str{nullptr};
   switch (inquiry) {
   case HashInquiryKeyword("ACCESS"):
+    if (!unit().IsConnected()) {
+      str = "UNDEFINED";
+    } else {
       switch (unit().access) {
       case Access::Sequential:
         str = "SEQUENTIAL";
         break;
       case Access::Direct:
         str = "DIRECT";
         break;
       case Access::Stream:
         str = "STREAM";
         break;
       }
+    }
     break;
   case HashInquiryKeyword("ACTION"):
-    str = unit().mayWrite() ? unit().mayRead() ? "READWRITE" : "WRITE" : "READ";
+    str = !unit().IsConnected() ? "UNDEFINED"
+        : unit().mayWrite()     ? unit().mayRead() ? "READWRITE" : "WRITE"
+                                : "READ";
     break;
   case HashInquiryKeyword("ASYNCHRONOUS"):
-    str = unit().mayAsynchronous() ? "YES" : "NO";
+    str = !unit().IsConnected()    ? "UNDEFINED"
+        : unit().mayAsynchronous() ? "YES"
+                                   : "NO";
     break;
   case HashInquiryKeyword("BLANK"):
-    str = unit().isUnformatted.value_or(true)   ? "UNDEFINED"
+    str = !unit().IsConnected() || unit().isUnformatted.value_or(true)
+        ? "UNDEFINED"
         : unit().modes.editingFlags & blankZero ? "ZERO"
                                                 : "NULL";
     break;
   case HashInquiryKeyword("CARRIAGECONTROL"):
     str = "LIST";
     break;
   case HashInquiryKeyword("CONVERT"):
     str = unit().swapEndianness() ? "SWAP" : "NATIVE";
     break;
   case HashInquiryKeyword("DECIMAL"):
-    str = unit().isUnformatted.value_or(true)      ? "UNDEFINED"
+    str = !unit().IsConnected() || unit().isUnformatted.value_or(true)
+        ? "UNDEFINED"
         : unit().modes.editingFlags & decimalComma ? "COMMA"
                                                    : "POINT";
     break;
   case HashInquiryKeyword("DELIM"):
-    if (unit().isUnformatted.value_or(true)) {
+    if (!unit().IsConnected() || unit().isUnformatted.value_or(true)) {
       str = "UNDEFINED";
     } else {
       switch (unit().modes.delim) {
       case '\'':
         str = "APOSTROPHE";
         break;
       case '"':
         str = "QUOTE";
         break;
       default:
         str = "NONE";
         break;
       }
     }
     break;
   case HashInquiryKeyword("DIRECT"):
-    str = unit().access == Access::Direct ||
+    str = !unit().IsConnected() ? "UNKNOWN"
+        : unit().access == Access::Direct ||
             (unit().mayPosition() && unit().isFixedRecordLength)
         ? "YES"
         : "NO";
     break;
   case HashInquiryKeyword("ENCODING"):
-    str = unit().isUnformatted.value_or(true) ? "UNDEFINED"
+    str = !unit().IsConnected()               ? "UNKNOWN"
+        : unit().isUnformatted.value_or(true) ? "UNDEFINED"
         : unit().isUTF8                       ? "UTF-8"
                                               : "ASCII";
     break;
   case HashInquiryKeyword("FORM"):
-    str = !unit().isUnformatted ? "UNDEFINED"
-        : *unit().isUnformatted ? "UNFORMATTED"
+    str = !unit().IsConnected() || !unit().isUnformatted ? "UNDEFINED"
+        : *unit().isUnformatted                          ? "UNFORMATTED"
                                                          : "FORMATTED";
     break;
   case HashInquiryKeyword("FORMATTED"):
-    str = !unit().isUnformatted ? "UNKNOWN"
+    str = !unit().IsConnected() ? "UNDEFINED"
+        : !unit().isUnformatted ? "UNKNOWN"
         : *unit().isUnformatted ? "NO"
                                 : "YES";
     break;
   case HashInquiryKeyword("NAME"):
     str = unit().path();
     if (!str) {
       return true; // result is undefined
     }
     break;
   case HashInquiryKeyword("PAD"):
-    str = unit().isUnformatted.value_or(true) ? "UNDEFINED"
-        : unit().modes.pad                    ? "YES"
-                                              : "NO";
+    str = !unit().IsConnected() || unit().isUnformatted.value_or(true)
+        ? "UNDEFINED"
+        : unit().modes.pad ? "YES"
     break;
   case HashInquiryKeyword("POSITION"):
-    if (unit().access == Access::Direct) {
+    if (!unit().IsConnected() || unit().access == Access::Direct) {
       str = "UNDEFINED";
     } else {
-      auto size{unit().knownSize()};
-      auto pos{unit().position()};
-      if (pos == size.value_or(pos + 1)) {
-        str = "APPEND";
-      } else if (pos == 0 && unit().mayPosition()) {
+      switch (unit().InquirePosition()) {
+      case Position::Rewind:
         str = "REWIND";
-      } else {
-        str = "ASIS"; // processor-dependent & no common behavior
+        break;
+      case Position::Append:
+        str = "APPEND";
+        break;
+      case Position::AsIs:
+        str = "ASIS";
+        break;
       }
     }
     break;
   case HashInquiryKeyword("READ"):
-    str = unit().mayRead() ? "YES" : "NO";
+    str = !unit().IsConnected() ? "UNDEFINED" : unit().mayRead() ? "YES" : "NO";
     break;
   case HashInquiryKeyword("READWRITE"):
-    str = unit().mayRead() && unit().mayWrite() ? "YES" : "NO";
+    str = !unit().IsConnected()                 ? "UNDEFINED"
+        : unit().mayRead() && unit().mayWrite() ? "YES"
+                                                : "NO";
     break;
   case HashInquiryKeyword("ROUND"):
-    if (unit().isUnformatted.value_or(true)) {
+    if (!unit().IsConnected() || unit().isUnformatted.value_or(true)) {
       str = "UNDEFINED";
     } else {
       switch (unit().modes.round) {
       case decimal::FortranRounding::RoundNearest:
         str = "NEAREST";
         break;
       case decimal::FortranRounding::RoundUp:
         str = "UP";
         break;
       case decimal::FortranRounding::RoundDown:
         str = "DOWN";
         break;
       case decimal::FortranRounding::RoundToZero:
         str = "ZERO";
         break;
       case decimal::FortranRounding::RoundCompatible:
         str = "COMPATIBLE";
         break;
       }
     }
     break;
   case HashInquiryKeyword("SEQUENTIAL"):
     // "NO" for Direct, since Sequential would not work if
     // the unit were reopened without RECL=.
-    str = unit().access == Access::Sequential ? "YES" : "NO";
+    str = !unit().IsConnected()               ? "UNKNOWN"
+        : unit().access == Access::Sequential ? "YES"
+                                              : "NO";
     break;
   case HashInquiryKeyword("SIGN"):
-    str = unit().isUnformatted.value_or(true)  ? "UNDEFINED"
+    str = !unit().IsConnected() || unit().isUnformatted.value_or(true)
+        ? "UNDEFINED"
         : unit().modes.editingFlags & signPlus ? "PLUS"
                                                : "SUPPRESS";
     break;
   case HashInquiryKeyword("STREAM"):
-    str = unit().access == Access::Stream ? "YES" : "NO";
-    break;
-  case HashInquiryKeyword("WRITE"):
-    str = unit().mayWrite() ? "YES" : "NO";
+    str = !unit().IsConnected()           ? "UNKNOWN"
+        : unit().access == Access::Stream ? "YES"
+                                          : "NO";
     break;
   case HashInquiryKeyword("UNFORMATTED"):
-    str = !unit().isUnformatted ? "UNKNOWN"
-        : *unit().isUnformatted ? "YES"
+    str = !unit().IsConnected() || !unit().isUnformatted ? "UNKNOWN"
+        : *unit().isUnformatted                          ? "YES"
                                                          : "NO";
     break;
+  case HashInquiryKeyword("WRITE"):
+    str = !unit().IsConnected() ? "UNKNOWN" : unit().mayWrite() ? "YES" : "NO";
+    break;
   }
   if (str) {
     ToFortranDefaultCharacter(result, length, str);
     return true;
   } else {
     BadInquiryKeywordHashCrash(inquiry);
     return false;
   }
 }
 
 bool InquireUnitState::Inquire(InquiryKeywordHash inquiry, bool &result) {
   switch (inquiry) {
   case HashInquiryKeyword("EXIST"):
     result = true;
     return true;
   case HashInquiryKeyword("NAMED"):
     result = unit().path() != nullptr;
     return true;
   case HashInquiryKeyword("OPENED"):
-    result = true;
+    result = unit().IsConnected();
     return true;
   case HashInquiryKeyword("PENDING"):
     result = false; // asynchronous I/O is not implemented
     return true;
   default:
     BadInquiryKeywordHashCrash(inquiry);
     return false;
   }
bool InquireUnitState::Inquire(
     InquiryKeywordHash inquiry, std::int64_t &result) {
   switch (inquiry) {
   case HashInquiryKeyword("NEXTREC"):
     if (unit().access == Access::Direct) {
       result = unit().currentRecordNumber;
     }
     return true;
   case HashInquiryKeyword("NUMBER"):
-    result = unit().unitNumber();
+    result = unit().IsConnected() ? unit().unitNumber() : -1;
     return true;
   case HashInquiryKeyword("POS"):
     result = unit().position();
     return true;
   case HashInquiryKeyword("RECL"):
-    if (unit().access == Access::Stream) {
+    if (!unit().IsConnected()) {
+      result = -1;
+    } else if (unit().access == Access::Stream) {
       result = -2;
     } else if (unit().isFixedRecordLength && unit().recordLength) {
       result = *unit().recordLength;
     } else {
       result = std::numeric_limits<std::uint32_t>::max();
     }
     return true;
   case HashInquiryKeyword("SIZE"):
+    result = -1;
+    if (unit().IsConnected()) {
       if (auto size{unit().knownSize()}) {
         result = *size;
-    } else {
-      result = -1;
+      }
     }
     return true;
   default:
     BadInquiryKeywordHashCrash(inquiry);
     return false;
   }
 }
 

flang/runtime/unit.h

 class UnitMap;
 class ChildIo;
 
 class ExternalFileUnit : public ConnectionState,
                          public OpenFile,
                          public FileFrame<ExternalFileUnit> {
 public:
   explicit ExternalFileUnit(int unitNumber) : unitNumber_{unitNumber} {}
+  ~ExternalFileUnit() {}
+
   int unitNumber() const { return unitNumber_; }
   bool swapEndianness() const { return swapEndianness_; }
   bool createdForInternalChildIo() const { return createdForInternalChildIo_; }
 
   static ExternalFileUnit *LookUp(int unit);
   static ExternalFileUnit &LookUpOrCrash(int unit, const Terminator &);
   static ExternalFileUnit &LookUpOrCreate(
       int unit, const Terminator &, bool &wasExtant);

flang/runtime/unit.cpp

void ExternalFileUnit::OpenUnit(std::optional<OpenStatus> status,
     std::optional<Action> action, Position position, OwningPtr<char> &&newPath,
     std::size_t newPathLength, Convert convert, IoErrorHandler &handler) {
   if (executionEnvironment.conversion != Convert::Unknown) {
     convert = executionEnvironment.conversion;
   }
   swapEndianness_ = convert == Convert::Swap ||
       (convert == Convert::LittleEndian && !isHostLittleEndian) ||
       (convert == Convert::BigEndian && isHostLittleEndian);
-  if (IsOpen()) {
+  if (IsConnected()) {
     bool isSamePath{newPath.get() && path() && pathLength() == newPathLength &&
         std::memcmp(path(), newPath.get(), newPathLength) == 0};
     if (status && *status != OpenStatus::Old && isSamePath) {
       handler.SignalError("OPEN statement for connected unit may not have "
                           "explicit STATUS= other than 'OLD'");
       return;
     }
     if (!newPath.get() || isSamePath) {