[flang] External I/O runtime work, repackaged (part 1)

[klausler]

Summary

Add a isFixedRecordLength flag member to Connection to
disambiguate the state of "record has known variable length"
from "record has fixed length". Code that sets and tests this
flag will appear in later patches. Rearrange data members to
reduce storage requirements, since Connection might indirectly
end up on a program stack frame. Add a utility member function
BeginRecord(); use it in internal I/O processing.

flang/runtime/connection.h

 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.
 struct ConnectionAttributes {
   Access access{Access::Sequential}; // ACCESS='SEQUENTIAL', 'DIRECT', 'STREAM'
-  std::optional<std::int64_t> recordLength; // RECL= when fixed-length
   bool isUnformatted{false}; // FORM='UNFORMATTED'
   bool isUTF8{false}; // ENCODING='UTF-8'
+  bool isFixedRecordLength{false}; // RECL= on OPEN
+  std::optional<std::int64_t> recordLength; // RECL= or current record
 };
 
 struct ConnectionState : public ConnectionAttributes {
   bool IsAtEOF() const; // true when read has hit EOF or endfile record
   std::size_t RemainingSpaceInRecord() const;
   void HandleAbsolutePosition(std::int64_t);
   void HandleRelativePosition(std::int64_t);
 
+  void BeginRecord() {
+    positionInRecord = 0;
+    furthestPositionInRecord = 0;
+    leftTabLimit.reset();
+  }
+
   // Positions in a record file (sequential or direct, not stream)
   std::int64_t currentRecordNumber{1}; // 1 is first
   std::int64_t positionInRecord{0}; // offset in current record
   std::int64_t furthestPositionInRecord{0}; // max(position+bytes)
   bool nonAdvancing{false}; // ADVANCE='NO'
 
   // Set at end of non-advancing I/O data transfer
   std::optional<std::int64_t> leftTabLimit; // offset in current record

flang/runtime/internal-unit.cpp

 #include <algorithm>
 #include <type_traits>
 
 namespace Fortran::runtime::io {
 
 template <Direction DIR>
 InternalDescriptorUnit<DIR>::InternalDescriptorUnit(
     Scalar scalar, std::size_t length) {
+  isFixedRecordLength = true;
   recordLength = length;
   endfileRecordNumber = 2;
   void *pointer{reinterpret_cast<void *>(const_cast<char *>(scalar))};
   descriptor().Establish(TypeCode{CFI_type_char}, length, pointer, 0, nullptr,
       CFI_attribute_pointer);
 }
 
 template <Direction DIR>
 InternalDescriptorUnit<DIR>::InternalDescriptorUnit(
     const Descriptor &that, const Terminator &terminator) {
   RUNTIME_CHECK(terminator, that.type().IsCharacter());
   Descriptor &d{descriptor()};
   RUNTIME_CHECK(
       terminator, that.SizeInBytes() <= d.SizeInBytes(maxRank, true, 0));
   new (&d) Descriptor{that};
   d.Check();
+  isFixedRecordLength = true;
   recordLength = d.ElementBytes();
   endfileRecordNumber = d.Elements() + 1;
 }
 
 template <Direction DIR> void InternalDescriptorUnit<DIR>::EndIoStatement() {
   if constexpr (DIR == Direction::Output) { // blank fill
     while (char *record{CurrentRecord()}) {
       if (furthestPositionInRecord <
if (furthestPositionInRecord <
         recordLength.value_or(furthestPositionInRecord)) {
       char *record{CurrentRecord()};
       RUNTIME_CHECK(handler, record != nullptr);
       std::fill_n(record + furthestPositionInRecord,
           *recordLength - furthestPositionInRecord, ' ');
     }
   }
   ++currentRecordNumber;
-  positionInRecord = 0;
-  furthestPositionInRecord = 0;
+  BeginRecord();
   return true;
 }
 
 template <Direction DIR>
 void InternalDescriptorUnit<DIR>::BackspaceRecord(IoErrorHandler &handler) {
   RUNTIME_CHECK(handler, currentRecordNumber > 1);
   --currentRecordNumber;
-  positionInRecord = 0;
-  furthestPositionInRecord = 0;
+  BeginRecord();
 }
 
 template class InternalDescriptorUnit<Direction::Output>;
 template class InternalDescriptorUnit<Direction::Input>;
 } // namespace Fortran::runtime::io