[flang] Don't blank-fill remaining lines in internal output

[klausler]

Summary

Internal writes to character arrays should not blank-fill
records (elements) past the last one that was written to.

[vdonaldson]

flang/unittests/Runtime/NumericalFormatTest.cpp

25

Is this temporary code?

[klausler]

flang/unittests/Runtime/NumericalFormatTest.cpp

25

Whoops! Thanks for noticing.

[klausler]

Remove debugging code from test.

flang/runtime/internal-unit.h

private:
   Descriptor &descriptor() { return staticDescriptor_.descriptor(); }
   const Descriptor &descriptor() const {
     return staticDescriptor_.descriptor();
   }
   Scalar CurrentRecord() const {
     return descriptor().template ZeroBasedIndexedElement<char>(
         currentRecordNumber - 1);
   }
+  void BlankFillOutputRecord();
+
   StaticDescriptor<maxRank, true /*addendum*/> staticDescriptor_;
 };
 
 extern template class InternalDescriptorUnit<Direction::Output>;
 extern template class InternalDescriptorUnit<Direction::Input>;
 } // namespace Fortran::runtime::io
 #endif // FORTRAN_RUNTIME_IO_INTERNAL_UNIT_H_

flang/runtime/internal-unit.cpp

RUNTIME_CHECK(
       terminator, that.SizeInBytes() <= d.SizeInBytes(maxRank, true, 0));
   new (&d) Descriptor{that};
   d.Check();
   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 <
-          recordLength.value_or(furthestPositionInRecord)) {
-        std::fill_n(record + furthestPositionInRecord,
-            *recordLength - furthestPositionInRecord, ' ');
-      }
-      furthestPositionInRecord = 0;
-      ++currentRecordNumber;
+  if constexpr (DIR == Direction::Output) {
+    if (furthestPositionInRecord > 0) {
+      BlankFillOutputRecord();
     }
   }
 }
 
 template <Direction DIR>
 bool InternalDescriptorUnit<DIR>::Emit(
     const char *data, std::size_t bytes, IoErrorHandler &handler) {
   if constexpr (DIR == Direction::Input) {

 }
 
 template <Direction DIR>
 bool InternalDescriptorUnit<DIR>::AdvanceRecord(IoErrorHandler &handler) {
   if (currentRecordNumber >= endfileRecordNumber.value_or(0)) {
     handler.SignalEnd();
     return false;
   }
-  if constexpr (DIR == Direction::Output) { // blank fill
+  if constexpr (DIR == Direction::Output) {
+    BlankFillOutputRecord();
+  }
+  ++currentRecordNumber;
+  BeginRecord();
+  return true;
+}
+
+template <Direction DIR>
+void InternalDescriptorUnit<DIR>::BlankFillOutputRecord() {
+  if constexpr (DIR == Direction::Output) {
     if (furthestPositionInRecord <
         recordLength.value_or(furthestPositionInRecord)) {
       char *record{CurrentRecord()};
-      RUNTIME_CHECK(handler, record != nullptr);
       std::fill_n(record + furthestPositionInRecord,
           *recordLength - furthestPositionInRecord, ' ');
     }
   }
-  ++currentRecordNumber;
-  BeginRecord();
-  return true;
 }
 
 template <Direction DIR>
 void InternalDescriptorUnit<DIR>::BackspaceRecord(IoErrorHandler &handler) {
   RUNTIME_CHECK(handler, currentRecordNumber > 1);
   --currentRecordNumber;
   BeginRecord();
 }
 
 template class InternalDescriptorUnit<Direction::Output>;
 template class InternalDescriptorUnit<Direction::Input>;
 } // namespace Fortran::runtime::io

flang/unittests/Runtime/NumericalFormatTest.cpp

 
 using namespace Fortran::runtime;
 using namespace Fortran::runtime::io;
 
 static bool CompareFormattedStrings(
     const std::string &expect, const std::string &&got) {
   std::string want{expect};
   want.resize(got.size(), ' ');
   return want == got;
 }
 
 static bool CompareFormattedStrings(
     const char *expect, const std::string &&got) {
   return CompareFormattedStrings(std::string(expect), std::move(got));
 }
 
 // Perform format and compare the result with expected value
TEST(IOApiTests, MultilineOutputTest) {
   section.Check();
 
   // Create format string and initialize IO operation
   const char *format{
       "('?abcde,',T1,'>',T9,A,TL12,A,TR25,'<'//G0,17X,'abcd',1(2I4))"};
   auto cookie{IONAME(BeginInternalArrayFormattedOutput)(
       section, format, std::strlen(format))};
 
+  // Fill last line with periods
+  std::memset(buffer[numLines - 1], '.', lineLength);
+
   // Write data to buffer
   IONAME(OutputAscii)(cookie, "WORLD", 5);
   IONAME(OutputAscii)(cookie, "HELLO", 5);
   IONAME(OutputInteger64)(cookie, 789);
   for (int j{666}; j <= 999; j += 111) {
     IONAME(OutputInteger64)(cookie, j);
   }
 
   // Ensure no errors occured in write operations above
   const auto status{IONAME(EndIoStatement)(cookie)};
   ASSERT_EQ(status, 0) << "multiline: '" << format << "' failed, status "
                        << static_cast<int>(status);
 
   static const std::string expect{">HELLO, WORLD                  <"
                                   "                                "
                                   "789                 abcd 666 777"
                                   " 888 999                        "
-                                  "                                "};
+                                  "................................"};
   // Ensure formatted string matches expected output
   EXPECT_TRUE(
       CompareFormattedStrings(expect, std::string{buffer[0], sizeof buffer}))
       << "Expected '" << expect << "' but got '"
       << std::string{buffer[0], sizeof buffer} << "'";
 }
 
 TEST(IOApiTests, ListInputTest) {