[flang] Acquire file accessibility, size, positioning

[klausler]

Summary

Extend the raw file wrapper to get accessibility, positioning,
and size information. This is needed for INQUIRE (to follow).

[PeteSteinfeld]

All builds, tests, and looks good.

flang/runtime/file.h

private:
   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

 #include <cerrno>
 #include <cstring>
 #include <fcntl.h>
 #include <stdlib.h>
 #ifdef _WIN32
 #include <io.h>
 #include <windows.h>
 #else
+#include <sys/stat.h>
 #include <unistd.h>
 #endif
 
 namespace Fortran::runtime::io {
 
 void OpenFile::set_path(OwningPtr<char> &&path, std::size_t bytes) {
   path_ = std::move(path);
   pathLength_ = bytes;
if (path_.get()) {
       path_.reset();
     }
     if (!action) {
       action = Action::ReadWrite;
     }
     fd_ = openfile_mkstemp(handler);
   } else {
     if (!path_.get()) {
-      handler.SignalError(
-          "FILE= is required unless STATUS='OLD' and unit is connected");
+      handler.SignalError("FILE= is required");
       return;
     }
     int flags{0};
     if (status != OpenStatus::Old) {
       flags |= O_CREAT;
     }
     if (status == OpenStatus::New) {
       flags |= O_EXCL;
void OpenFile::Open(OpenStatus status, std::optional<Action> action,
   if (position == Position::Append && !RawSeekToEnd()) {
     handler.SignalErrno();
   }
   isTerminal_ = ::isatty(fd_) == 1;
   mayRead_ = *action != Action::Write;
   mayWrite_ = *action != Action::Read;
   if (status == OpenStatus::Old || status == OpenStatus::Unknown) {
     knownSize_.reset();
+#ifndef _WIN32
+    struct stat buf;
+    if (::fstat(fd_, &buf) == 0) {
+      mayPosition_ = S_ISREG(buf.st_mode);
+      knownSize_ = buf.st_size;
+    }
+#else // TODO: _WIN32
+    mayPosition_ = true;
+#endif
   } else {
     knownSize_ = 0;
+    mayPosition_ = true;
   }
 }
 
 void OpenFile::Predefine(int fd) {
   fd_ = fd;
   path_.reset();
   pathLength_ = 0;
   position_ = 0;

 
 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); }
+
+bool IsExtant(const char *path) { return ::access(path, F_OK) == 0; }
+bool MayRead(const char *path) { return ::access(path, R_OK) == 0; }
+bool MayWrite(const char *path) { return ::access(path, W_OK) == 0; }
+bool MayReadAndWrite(const char *path) {
+  return ::access(path, R_OK | W_OK) == 0;
+}
 } // namespace Fortran::runtime::io