[flang][runtime] Reset the left tab limit when flushing output

[klausler]

Summary

When flushing output to a non-positionable tty or socket file, reset the
left tab limit. Otherwise, non-advancing output to that file will contain
an increasing amount of leading spaces in each flush.

flang/runtime/emit-encoded.h

 //===-- runtime/emit-encoded.h ----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Templates for emitting CHARACTER values with conversion
 
 #ifndef FORTRAN_RUNTIME_EMIT_ENCODED_H_
 #define FORTRAN_RUNTIME_EMIT_ENCODED_H_
 
 #include "connection.h"
 #include "environment.h"
+#include "tools.h"
 #include "utf.h"
 
 namespace Fortran::runtime::io {
 
 template <typename CONTEXT, typename CHAR>
 bool EmitEncoded(CONTEXT &to, const CHAR *data, std::size_t chars) {
   ConnectionState &connection{to.GetConnectionState()};
+  if (connection.access == Access::Stream &&
+      connection.internalIoCharKind == 0) {
+    // Stream output: treat newlines as record advancements so that the left tab
+    // limit is correctly managed
+    while (const CHAR * nl{FindCharacter(data, CHAR{'\n'}, chars)}) {
+      auto pos{static_cast<std::size_t>(nl - data)};
+      if (!EmitEncoded(to, data, pos)) {
+        return false;
+      }
+      data += pos + 1;
+      chars -= pos + 1;
+      to.AdvanceRecord();
+    }
+  }
   if (connection.useUTF8<CHAR>()) {
     using UnsignedChar = std::make_unsigned_t<CHAR>;
     const UnsignedChar *uData{reinterpret_cast<const UnsignedChar *>(data)};
     char buffer[256];
     std::size_t at{0};
     while (chars-- > 0) {
       auto len{EncodeUTF8(buffer + at, *uData++)};
       at += len;
if (internalKind == 0 || internalKind == sizeof(CHAR)) {
       return true;
     }
   }
 }
 
 template <typename CONTEXT>
 bool EmitAscii(CONTEXT &to, const char *data, std::size_t chars) {
   ConnectionState &connection{to.GetConnectionState()};
-  if (connection.internalIoCharKind <= 1) {
+  if (connection.internalIoCharKind <= 1 &&
+      connection.access != Access::Stream) {
     return to.Emit(data, chars);
   } else {
     return EmitEncoded(to, data, chars);
   }
 }
 
 template <typename CONTEXT>
 bool EmitRepeated(CONTEXT &to, char ch, std::size_t n) {
   if (n <= 0) {
     return true;
   }
   ConnectionState &connection{to.GetConnectionState()};
-  if (connection.internalIoCharKind <= 1) {
+  if (connection.internalIoCharKind <= 1 &&
+      connection.access != Access::Stream) {
+    // faster path, no encoding needed
     while (n-- > 0) {
       if (!to.Emit(&ch, 1)) {
         return false;
       }
     }
   } else {
     while (n-- > 0) {
       if (!EmitEncoded(to, &ch, 1)) {

flang/runtime/tools.h

 //===-- runtime/tools.h -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_RUNTIME_TOOLS_H_
 #define FORTRAN_RUNTIME_TOOLS_H_
 
 #include "terminator.h"
 #include "flang/Runtime/cpp-type.h"
 #include "flang/Runtime/descriptor.h"
 #include "flang/Runtime/memory.h"
+#include <cstring>
 #include <functional>
 #include <map>
 #include <type_traits>
 
 namespace Fortran::runtime {
 
 class Terminator;
 

 
 // Accumulate floating-point results in (at least) double precision
 template <TypeCategory CAT, int KIND>
 using AccumulationType = CppTypeFor<CAT,
     CAT == TypeCategory::Real || CAT == TypeCategory::Complex
         ? std::max(KIND, static_cast<int>(sizeof(double)))
         : KIND>;
 
+// memchr() for any character type
+template <typename CHAR>
+static inline const CHAR *FindCharacter(
+    const CHAR *data, CHAR ch, std::size_t chars) {
+  const CHAR *end{data + chars};
+  for (const CHAR *p{data}; p < end; ++p) {
+    if (*p == ch) {
+      return p;
+    }
+  }
+  return nullptr;
+}
+
+template <>
+inline const char *FindCharacter(const char *data, char ch, std::size_t chars) {
+  return reinterpret_cast<const char *>(
+      std::memchr(data, static_cast<int>(ch), chars));
+}
+
 } // namespace Fortran::runtime
 #endif // FORTRAN_RUNTIME_TOOLS_H_

flang/runtime/unit.cpp

 //===-- runtime/unit.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "unit.h"
 #include "io-error.h"
 #include "lock.h"
+#include "tools.h"
 #include "unit-map.h"
 #include <cstdio>
 #include <limits>
 #include <utility>
 
 namespace Fortran::runtime::io {
 
 // The per-unit data structures are created on demand so that Fortran I/O

 }
 
 bool ExternalFileUnit::SetVariableFormattedRecordLength() {
   if (recordLength || access == Access::Direct) {
     return true;
   } else if (FrameLength() > recordOffsetInFrame_) {
     const char *record{Frame() + recordOffsetInFrame_};
     std::size_t bytes{FrameLength() - recordOffsetInFrame_};
-    if (const char *nl{
-            reinterpret_cast<const char *>(std::memchr(record, '\n', bytes))}) {
+    if (const char *nl{FindCharacter(record, '\n', bytes)}) {
       recordLength = nl - record;
       if (*recordLength > 0 && record[*recordLength - 1] == '\r') {
         --*recordLength;
       }
       return true;
     }
   }
   return false;
if (!mayPosition()) {
     auto frameAt{FrameAt()};
     if (frameOffsetInFile_ >= frameAt &&
         frameOffsetInFile_ <
             static_cast<std::int64_t>(frameAt + FrameLength())) {
       // A Flush() that's about to happen to a non-positionable file
       // needs to advance frameOffsetInFile_ to prevent attempts at
       // impossible seeks
       CommitWrites();
+      leftTabLimit.reset();
     }
   }
   Flush(handler);
 }
 
 void ExternalFileUnit::FlushIfTerminal(IoErrorHandler &handler) {
   if (isTerminal()) {
     FlushOutput(handler);