[flang] Track known file size, add IsATerminal (ext. I/O work part 5)

[klausler]

Summary

Add a data member knownSize_ and an accessor to allow the size of
an external file to be tracked when known. Also add a wrapper for
::isatty() here in the filesystem encapsulation module. These
features are needed for the external I/O rework changes still
to come.

flang/runtime/file.h

public:
   bool mayWrite() const { return mayWrite_; }
   void set_mayWrite(bool yes) { mayWrite_ = yes; }
   bool mayAsynchronous() const { return mayAsynchronous_; }
   void set_mayAsynchronous(bool yes) { mayAsynchronous_ = yes; }
   bool mayPosition() const { return mayPosition_; }
   void set_mayPosition(bool yes) { mayPosition_ = yes; }
   FileOffset position() const { return position_; }
   bool isTerminal() const { return isTerminal_; }
+  std::optional<FileOffset> knownSize() const { return knownSize_; }
 
   bool IsOpen() const { return fd_ >= 0; }
   void Open(OpenStatus, 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
private:
   bool mayAsynchronous_{false};
   FileOffset position_{0};
   std::optional<FileOffset> knownSize_;
   bool isTerminal_{false};
 
   int nextId_;
   OwningPtr<Pending> pending_;
 };
+
+bool IsATerminal(int fd);
 } // namespace Fortran::runtime::io
 #endif // FORTRAN_RUNTIME_FILE_H_

flang/runtime/file.cpp

 void OpenFile::Open(
     OpenStatus status, Position position, IoErrorHandler &handler) {
   int flags{mayRead_ ? mayWrite_ ? O_RDWR : O_RDONLY : O_WRONLY};
   switch (status) {
   case OpenStatus::Old:
     if (fd_ >= 0) {
       return;
     }
+    knownSize_.reset();
     break;
   case OpenStatus::New:
     flags |= O_CREAT | O_EXCL;
+    knownSize_ = 0;
     break;
   case OpenStatus::Scratch:
     if (path_.get()) {
       handler.SignalError("FILE= must not appear with STATUS='SCRATCH'");
       path_.reset();
     }
     fd_ = openfile_mkstemp(handler);
+    knownSize_ = 0;
     return;
   case OpenStatus::Replace:
     flags |= O_CREAT | O_TRUNC;
+    knownSize_ = 0;
     break;
   case OpenStatus::Unknown:
     if (fd_ >= 0) {
       return;
     }
     flags |= O_CREAT;
+    knownSize_.reset();
     break;
   }
   // If we reach this point, we're opening a new file.
   // TODO: Fortran shouldn't create a new file until the first WRITE.
   if (fd_ >= 0) {
     if (fd_ <= 2) {
       // don't actually close a standard file descriptor, we might need it
     } else if (::close(fd_) != 0) {
       handler.SignalErrno();
     }
   }
   if (!path_.get()) {
     handler.SignalError(
         "FILE= is required unless STATUS='OLD' and unit is connected");
     return;
   }
   fd_ = ::open(path_.get(), flags, 0600);
   if (fd_ < 0) {
     handler.SignalErrno();
   }
   pending_.reset();
-  knownSize_.reset();
   if (position == Position::Append && !RawSeekToEnd()) {
     handler.SignalErrno();
   }
   isTerminal_ = ::isatty(fd_) == 1;
 }
 
 void OpenFile::Predefine(int fd) {
   fd_ = fd;
std::size_t OpenFile::Read(FileOffset at, char *buffer, std::size_t minBytes,
     std::size_t maxBytes, IoErrorHandler &handler) {
   if (maxBytes == 0) {
     return 0;
   }
   CheckOpen(handler);
   if (!Seek(at, handler)) {
     return 0;
   }
-  if (maxBytes < minBytes) {
-    minBytes = maxBytes;
-  }
+  minBytes = std::min(minBytes, maxBytes);
   std::size_t got{0};
   while (got < minBytes) {
     auto chunk{::read(fd_, buffer + got, maxBytes - got)};
     if (chunk == 0) {
       handler.SignalEnd();
       break;
-    }
-    if (chunk < 0) {
+    } else if (chunk < 0) {
       auto err{errno};
       if (err != EAGAIN && err != EWOULDBLOCK && err != EINTR) {
         handler.SignalError(err);
         break;
       }
     } else {
       position_ += chunk;
       got += chunk;
#endif
   }
 }
 
 int OpenFile::PendingResult(const Terminator &terminator, int iostat) {
   int id{nextId_++};
   pending_ = New<Pending>{terminator}(id, iostat, std::move(pending_));
   return id;
 }
+
+bool IsATerminal(int fd) { return ::isatty(fd); }
 } // namespace Fortran::runtime::io