[flang] Always encode multi-byte output in UTF-8

[klausler]

Summary

A recent change to implement UTF-8 encoding should have
made the encoding conditional only for CHARACTER(KIND=1)
to enable UTF-8 output vs. Latin-1 or whatever. UTF-8 output
of wider CHARACTER kinds should not be conditional (until we choose
to support UCS-16, maybe). So wider CHARACTER kinds are being
emitted with extra zero bytes; this patch fixes them.

[jeanPerier]

Thanks

flang/runtime/connection.h

struct ConnectionAttributes {
   std::optional<bool> isUnformatted; // FORM='UNFORMATTED' if true
   bool isUTF8{false}; // ENCODING='UTF-8'
   std::optional<std::int64_t> openRecl; // RECL= on OPEN
 
   bool IsRecordFile() const {
     // Formatted stream files are viewed as having records, at least on input
     return access != Access::Stream || !isUnformatted.value_or(true);
   }
+
+  template <typename CHAR = char> constexpr bool useUTF8() const {
+    // For wide CHARACTER kinds, always use UTF-8 for formatted I/O.
+    // For single-byte CHARACTER, encode characters >= 0x80 with
+    // UTF-8 iff the mode is set.
+    return sizeof(CHAR) > 1 || isUTF8;
+  }
 };
 
 struct ConnectionState : public ConnectionAttributes {
   bool IsAtEOF() const; // true when read has hit EOF or endfile record
   bool IsAfterEndfile() const; // true after ENDFILE until repositioned
   std::size_t RemainingSpaceInRecord() const;
   bool NeedAdvance(std::size_t) const;
   void HandleAbsolutePosition(std::int64_t);

flang/runtime/edit-output.cpp

for (std::size_t j{0}; j < length; ++j) {
       }
       EmitOne(x[j]);
     }
     EmitOne(modes.delim);
   } else {
     // Undelimited list-directed output
     ok = ok && list.EmitLeadingSpaceOrAdvance(io, length > 0 ? 1 : 0, true);
     std::size_t put{0};
-    std::size_t oneIfUTF8{connection.isUTF8 ? 1 : length};
+    std::size_t oneIfUTF8{connection.useUTF8<CHAR>() ? 1 : length};
     while (ok && put < length) {
       if (std::size_t chunk{std::min<std::size_t>(
               std::min<std::size_t>(length - put, oneIfUTF8),
               connection.RemainingSpaceInRecord())}) {
         ok = io.EmitEncoded(x + put, chunk);
         put += chunk;
       } else {
         ok = io.AdvanceRecord() && io.Emit(" ", 1);

flang/runtime/io-stmt.cpp

bool IoStatementState::Emit(const char32_t *data, std::size_t chars) {
   return std::visit([=](auto &x) { return x.get().Emit(data, chars); }, u_);
 }
 
 template <typename CHAR>
 bool IoStatementState::EmitEncoded(const CHAR *data0, std::size_t chars) {
   // Don't allow sign extension
   using UnsignedChar = std::make_unsigned_t<CHAR>;
   const UnsignedChar *data{reinterpret_cast<const UnsignedChar *>(data0)};
-  if (GetConnectionState().isUTF8) {
+  if (GetConnectionState().useUTF8<CHAR>()) {
     char buffer[256];
     std::size_t at{0};
     while (chars-- > 0) {
       auto len{EncodeUTF8(buffer + at, *data++)};
       at += len;
       if (at + maxUTF8Bytes > sizeof buffer) {
         if (!Emit(buffer, at)) {
           return false;