[flang][runtime] Support internal I/O to CHARACTER(KIND/=1)

[klausler]

Summary

Allow internal I/O to support non-default kinds of CHARACTER.

The I/O runtime design anticipated this standard feature, but
this patch is somewhat larger than I thought it would be because
many code sites had to have assumptions about units (characters
vs. bytes) brought into harmony, and some encoding utilities
had to be pulled out of IoStatementState and templatized into
their own new header file so that they are available to formatted
output code without having to "thread" an IoStatementState reference
through many call chains.

flang/lib/Semantics/check-io.cpp

void IoChecker::Enter(const parser::IoUnit &spec) {
   if (const parser::Variable * var{std::get_if<parser::Variable>(&spec.u)}) {
     if (stmt_ == IoStmtKind::Write) {
       CheckForDefinableVariable(*var, "Internal file");
     }
     if (const auto *expr{GetExpr(context_, *var)}) {
       if (HasVectorSubscript(*expr)) {
         context_.Say(parser::FindSourceLocation(*var), // C1201
             "Internal file must not have a vector subscript"_err_en_US);
-      } else if (!ExprTypeKindIsDefault(*expr, context_)) {
-        // This may be too restrictive; other kinds may be valid.
-        context_.Say(parser::FindSourceLocation(*var), // C1202
-            "Invalid character kind for an internal file variable"_err_en_US);
       }
     }
     SetSpecifier(IoSpecKind::Unit);
     flags_.set(Flag::InternalUnit);
   } else if (std::get_if<parser::Star>(&spec.u)) {
     SetSpecifier(IoSpecKind::Unit);
     flags_.set(Flag::StarUnit);
   }

flang/runtime/connection.h

 enum class Access { Sequential, Direct, 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<bool> isUnformatted; // FORM='UNFORMATTED' if true
   bool isUTF8{false}; // ENCODING='UTF-8'
+  unsigned char internalIoCharKind{0}; // 0->external, 1/2/4->internal
   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;
+    return internalIoCharKind == 0 && (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
+
+  // All positions and measurements are always in units of bytes,
+  // not characters.  Multi-byte character encodings are possible in
+  // both internal I/O (when the character kind of the variable is 2 or 4)
+  // and external formatted I/O (when the encoding is UTF-8).
   std::size_t RemainingSpaceInRecord() const;
   bool NeedAdvance(std::size_t) const;
   void HandleAbsolutePosition(std::int64_t);
   void HandleRelativePosition(std::int64_t);
 
   void BeginRecord() {
     positionInRecord = 0;
     furthestPositionInRecord = 0;
     unterminatedRecord = false;
   }
 
   std::optional<std::int64_t> EffectiveRecordLength() const {
     // When an input record is longer than an explicit RECL= from OPEN
     // it is effectively truncated on input.
     return openRecl && recordLength && *openRecl < *recordLength ? openRecl
                                                                  : recordLength;
   }
 
   std::optional<std::int64_t> recordLength;
 
   std::int64_t currentRecordNumber{1}; // 1 is first
 
-  // positionInRecord is the 0-based offset in the current recurd to/from
-  // which the next data transfer will occur.  It can be past
+  // positionInRecord is the 0-based bytes offset in the current recurd
+  // to/from which the next data transfer will occur.  It can be past
   // furthestPositionInRecord if moved by an X or T or TR control edit
   // descriptor.
   std::int64_t positionInRecord{0};
 
-  // furthestPositionInRecord is the 0-based offset of the greatest
+  // furthestPositionInRecord is the 0-based byte offset of the greatest
   // position in the current record to/from which any data transfer has
   // occurred, plus one.  It can be viewed as a count of bytes processed.
   std::int64_t furthestPositionInRecord{0}; // max(position+bytes)
 
   // Set at end of non-advancing I/O data transfer
   std::optional<std::int64_t> leftTabLimit; // offset in current record
 
   // currentRecordNumber value captured after ENDFILE/REWIND/BACKSPACE statement

flang/runtime/edit-input.cpp

 #include <algorithm>
 #include <cfenv>
 
 namespace Fortran::runtime::io {
 
 template <int LOG2_BASE>
 static bool EditBOZInput(
     IoStatementState &io, const DataEdit &edit, void *n, std::size_t bytes) {
-  std::optional<int> remaining;
-  std::optional<char32_t> next{io.PrepareInput(edit, remaining)};
+  // Skip leading white space & zeroes
+  std::optional<int> remaining{io.CueUpInput(edit)};
+  auto start{io.GetConnectionState().positionInRecord};
+  std::optional<char32_t> next{io.NextInField(remaining, edit)};
   if (next.value_or('?') == '0') {
     do {
+      start = io.GetConnectionState().positionInRecord;
       next = io.NextInField(remaining, edit);
     } while (next && *next == '0');
   }
   // Count significant digits after any leading white space & zeroes
   int digits{0};
-  int chars{0};
   for (; next; next = io.NextInField(remaining, edit)) {
-    ++chars;
     char32_t ch{*next};
     if (ch == ' ' || ch == '\t') {
       continue;
     }
     if (ch >= '0' && ch <= '1') {
     } else if (LOG2_BASE >= 3 && ch >= '2' && ch <= '7') {
     } else if (LOG2_BASE >= 4 && ch >= '8' && ch <= '9') {
     } else if (LOG2_BASE >= 4 && ch >= 'A' && ch <= 'F') {
     } else if (LOG2_BASE >= 4 && ch >= 'a' && ch <= 'f') {
     } else {
       io.GetIoErrorHandler().SignalError(
           "Bad character '%lc' in B/O/Z input field", ch);
       return false;
     }
     ++digits;
   }
   auto significantBytes{static_cast<std::size_t>(digits * LOG2_BASE + 7) / 8};
   if (significantBytes > bytes) {
     io.GetIoErrorHandler().SignalError(IostatBOZInputOverflow,
         "B/O/Z input of %d digits overflows %zd-byte variable", digits, bytes);
     return false;
   }
   // Reset to start of significant digits
-  io.HandleRelativePosition(-chars);
+  io.HandleAbsolutePosition(start);
   remaining.reset();
   // Make a second pass now that the digit count is known
   std::memset(n, 0, bytes);
   int increment{isHostLittleEndian ? -1 : 1};
   auto *data{reinterpret_cast<unsigned char *>(n) +
       (isHostLittleEndian ? significantBytes - 1 : 0)};
   int shift{((digits - 1) * LOG2_BASE) & 7};
   if (shift + LOG2_BASE > 8) {

 static inline char32_t GetDecimalPoint(const DataEdit &edit) {
   return edit.modes.editingFlags & decimalComma ? char32_t{','} : char32_t{'.'};
 }
 
 // Prepares input from a field, and consumes the sign, if any.
 // Returns true if there's a '-' sign.
 static bool ScanNumericPrefix(IoStatementState &io, const DataEdit &edit,
     std::optional<char32_t> &next, std::optional<int> &remaining) {
-  next = io.PrepareInput(edit, remaining);
+  remaining = io.CueUpInput(edit);
+  next = io.NextInField(remaining, edit);
   bool negative{false};
   if (next) {
     negative = *next == '-';
     if (negative || *next == '+') {
       io.SkipSpaces(remaining);
       next = io.NextInField(remaining, edit);
     }
   }

 static bool TryFastPathRealInput(
     IoStatementState &io, const DataEdit &edit, void *n) {
   if (edit.modes.editingFlags & (blankZero | decimalComma)) {
     return false;
   }
   if (edit.modes.scale != 0) {
     return false;
   }
+  const ConnectionState &connection{io.GetConnectionState()};
+  if (connection.internalIoCharKind > 1) {
+    return false; // reading non-default character
+  }
   const char *str{nullptr};
   std::size_t got{io.GetNextInputBytes(str)};
-  if (got == 0 || str == nullptr ||
-      !io.GetConnectionState().recordLength.has_value()) {
+  if (got == 0 || str == nullptr || !connection.recordLength.has_value()) {
     return false; // could not access reliably-terminated input stream
   }
   const char *p{str};
   std::int64_t maxConsume{
       std::min<std::int64_t>(got, edit.width.value_or(got))};
   const char *limit{str + maxConsume};
   decimal::ConversionToBinaryResult<PRECISION> converted{
       decimal::ConvertToBinary<PRECISION>(p, edit.modes.round, limit)};
bool EditLogicalInput(IoStatementState &io, const DataEdit &edit, bool &x) {
   case 'G':
     break;
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
         "Data edit descriptor '%c' may not be used for LOGICAL input",
         edit.descriptor);
     return false;
   }
-  std::optional<int> remaining;
-  std::optional<char32_t> next{io.PrepareInput(edit, remaining)};
+  std::optional<int> remaining{io.CueUpInput(edit)};
+  std::optional<char32_t> next{io.NextInField(remaining, edit)};
   if (next && *next == '.') { // skip optional period
     next = io.NextInField(remaining, edit);
   }
   if (!next) {
     io.GetIoErrorHandler().SignalError("Empty LOGICAL input field");
     return false;
   }
   switch (*next) {
if (connection.isUTF8) {
       } else if (auto ucs{DecodeUTF8(input)}) {
         *x++ = *ucs;
         --length;
       } else if (chunk == 0) {
         // error recovery: skip bad encoding
         chunk = 1;
       }
       --remaining;
+    } else if (connection.internalIoCharKind > 1) {
+      // Reading from non-default character internal unit
+      chunk = connection.internalIoCharKind;
+      if (skipping) {
+        --skip;
+      } else {
+        char32_t buffer{0};
+        std::memcpy(&buffer, input, chunk);
+        *x++ = buffer;
+        --length;
+      }
+      --remaining;
     } else if constexpr (sizeof *x > 1) {
       // Read single byte with expansion into multi-byte CHARACTER
       chunk = 1;
       if (skipping) {
         --skip;
       } else {
         *x++ = static_cast<unsigned char>(*input);
         --length;

flang/runtime/edit-output.cpp

 //===-- runtime/edit-output.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 "edit-output.h"
+#include "emit-encoded.h"
 #include "utf.h"
 #include "flang/Common/uint128.h"
 #include <algorithm>
 
 namespace Fortran::runtime::io {
 
 // B/O/Z output of arbitrarily sized data emits a binary/octal/hexadecimal
 // representation of what is interpreted to be a single unsigned integer value.
if (*edit.digits == 0 && bytes == 0) {
       leadingZeroes = *edit.digits - significant;
     }
   } else if (bytes == 0) {
     leadingZeroes = 1;
   }
   int subTotal{leadingZeroes + significant};
   int leadingSpaces{std::max(0, editWidth - subTotal)};
   if (editWidth > 0 && leadingSpaces + subTotal > editWidth) {
-    return io.EmitRepeated('*', editWidth);
+    return EmitRepeated(io, '*', editWidth);
   }
-  if (!(io.EmitRepeated(' ', leadingSpaces) &&
-          io.EmitRepeated('0', leadingZeroes))) {
+  if (!(EmitRepeated(io, ' ', leadingSpaces) &&
+          EmitRepeated(io, '0', leadingZeroes))) {
     return false;
   }
   // Emit remaining digits
   while (bytes > 0) {
     if (get == 0) {
       char ch{static_cast<char>(digit >= 10 ? 'A' + digit - 10 : '0' + digit)};
-      if (!io.Emit(&ch, 1)) {
+      if (!EmitAscii(io, &ch, 1)) {
         return false;
       }
       get = LOG2_BASE;
       digit = 0;
     } else if (shift < 0) {
       data += increment;
       --bytes;
       shift = 7;
if (*edit.digits == 0 && n == 0) {
       leadingZeroes = *edit.digits - digits;
     }
   } else if (n == 0) {
     leadingZeroes = 1;
   }
   int subTotal{signChars + leadingZeroes + digits};
   int leadingSpaces{std::max(0, editWidth - subTotal)};
   if (editWidth > 0 && leadingSpaces + subTotal > editWidth) {
-    return io.EmitRepeated('*', editWidth);
+    return EmitRepeated(io, '*', editWidth);
   }
   if (edit.IsListDirected()) {
     int total{std::max(leadingSpaces, 1) + subTotal};
     if (io.GetConnectionState().NeedAdvance(static_cast<std::size_t>(total)) &&
         !io.AdvanceRecord()) {
       return false;
     }
     leadingSpaces = 1;
   }
-  return io.EmitRepeated(' ', leadingSpaces) &&
-      io.Emit(n < 0 ? "-" : "+", signChars) &&
-      io.EmitRepeated('0', leadingZeroes) && io.Emit(p, digits);
+  return EmitRepeated(io, ' ', leadingSpaces) &&
+      EmitAscii(io, n < 0 ? "-" : "+", signChars) &&
+      EmitRepeated(io, '0', leadingZeroes) && EmitAscii(io, p, digits);
 }
 
 // Formats the exponent (see table 13.1 for all the cases)
 const char *RealOutputEditingBase::FormatExponent(
     int expo, const DataEdit &edit, int &length) {
   char *eEnd{&exponent_[sizeof exponent_]};
   char *exponent{eEnd};
   for (unsigned e{static_cast<unsigned>(std::abs(expo))}; e > 0;) {
int prefixLength{edit.descriptor == DataEdit::ListDirectedRealPart ? 2
                                                                        : 1};
     int suffixLength{edit.descriptor == DataEdit::ListDirectedRealPart ||
                 edit.descriptor == DataEdit::ListDirectedImaginaryPart
             ? 1
             : 0};
     length += prefixLength + suffixLength;
     ConnectionState &connection{io_.GetConnectionState()};
     return (!connection.NeedAdvance(length) || io_.AdvanceRecord()) &&
-        io_.Emit(" (", prefixLength);
+        EmitAscii(io_, " (", prefixLength);
   } else if (width > length) {
-    return io_.EmitRepeated(' ', width - length);
+    return EmitRepeated(io_, ' ', width - length);
   } else {
     return true;
   }
 }
 
 bool RealOutputEditingBase::EmitSuffix(const DataEdit &edit) {
   if (edit.descriptor == DataEdit::ListDirectedRealPart) {
-    return io_.Emit(edit.modes.editingFlags & decimalComma ? ";" : ",", 1);
+    return EmitAscii(
+        io_, edit.modes.editingFlags & decimalComma ? ";" : ",", 1);
   } else if (edit.descriptor == DataEdit::ListDirectedImaginaryPart) {
-    return io_.Emit(")", 1);
+    return EmitAscii(io_, ")", 1);
   } else {
     return true;
   }
 }
 
 template <int binaryPrecision>
 decimal::ConversionToDecimalResult RealOutputEditing<binaryPrecision>::Convert(
     int significantDigits, enum decimal::FortranRounding rounding, int flags) {
if (isEN) {
     scale = std::min(scale, significantDigits + 1);
   }
   // In EN editing, multiple attempts may be necessary, so this is a loop.
   while (true) {
     decimal::ConversionToDecimalResult converted{
         Convert(significantDigits, edit.modes.round, flags)};
     if (IsInfOrNaN(converted)) {
       return EmitPrefix(edit, converted.length, editWidth) &&
-          io_.Emit(converted.str, converted.length) && EmitSuffix(edit);
+          EmitAscii(io_, converted.str, converted.length) && EmitSuffix(edit);
     }
     if (!IsZero()) {
       converted.decimalExponent -= scale;
     }
     if (isEN) {
       // EN mode: we need an effective exponent field that is
       // a multiple of three.
       if (int modulus{converted.decimalExponent % 3}; modulus != 0) {
int trailingZeroes{flags & decimal::Minimize
             ? 0
             : std::max(0,
                   significantDigits - (convertedDigits + zeroesBeforePoint))};
     int totalLength{signLength + digitsBeforePoint + zeroesBeforePoint +
         1 /*'.'*/ + zeroesAfterPoint + digitsAfterPoint + trailingZeroes +
         expoLength};
     int width{editWidth > 0 ? editWidth : totalLength};
     if (totalLength > width || !exponent) {
-      return io_.EmitRepeated('*', width);
+      return EmitRepeated(io_, '*', width);
     }
     if (totalLength < width && digitsBeforePoint == 0 &&
         zeroesBeforePoint == 0) {
       zeroesBeforePoint = 1;
       ++totalLength;
     }
     if (totalLength < width && noLeadingSpaces) {
       width = totalLength;
     }
     return EmitPrefix(edit, totalLength, width) &&
-        io_.Emit(converted.str, signLength + digitsBeforePoint) &&
-        io_.EmitRepeated('0', zeroesBeforePoint) &&
-        io_.Emit(edit.modes.editingFlags & decimalComma ? "," : ".", 1) &&
-        io_.EmitRepeated('0', zeroesAfterPoint) &&
-        io_.Emit(
-            converted.str + signLength + digitsBeforePoint, digitsAfterPoint) &&
-        io_.EmitRepeated('0', trailingZeroes) &&
-        io_.Emit(exponent, expoLength) && EmitSuffix(edit);
+        EmitAscii(io_, converted.str, signLength + digitsBeforePoint) &&
+        EmitRepeated(io_, '0', zeroesBeforePoint) &&
+        EmitAscii(io_, edit.modes.editingFlags & decimalComma ? "," : ".", 1) &&
+        EmitRepeated(io_, '0', zeroesAfterPoint) &&
+        EmitAscii(io_, converted.str + signLength + digitsBeforePoint,
+            digitsAfterPoint) &&
+        EmitRepeated(io_, '0', trailingZeroes) &&
+        EmitAscii(io_, exponent, expoLength) && EmitSuffix(edit);
   }
 }
 
 // 13.7.2.3.2 in F'2018
 template <int binaryPrecision>
 bool RealOutputEditing<binaryPrecision>::EditFOutput(const DataEdit &edit) {
   int fracDigits{edit.digits.value_or(0)}; // 'd' field
   const int editWidth{edit.width.value_or(0)}; // 'w' field
bool RealOutputEditing<binaryPrecision>::EditFOutput(const DataEdit &edit) {
   // effective rounded fractional digits.
   int extraDigits{0};
   bool canIncrease{true};
   while (true) {
     decimal::ConversionToDecimalResult converted{
         Convert(extraDigits + fracDigits, rounding, flags)};
     if (IsInfOrNaN(converted)) {
       return EmitPrefix(edit, converted.length, editWidth) &&
-          io_.Emit(converted.str, converted.length) && EmitSuffix(edit);
+          EmitAscii(io_, converted.str, converted.length) && EmitSuffix(edit);
     }
     int expo{converted.decimalExponent + edit.modes.scale /*kP*/};
     int signLength{*converted.str == '-' || *converted.str == '+' ? 1 : 0};
     int convertedDigits{static_cast<int>(converted.length) - signLength};
     if (IsZero()) { // don't treat converted "0" as significant digit
       expo = 0;
       convertedDigits = 0;
     }
if (digitsBeforePoint + zeroesBeforePoint + zeroesAfterPoint +
         0) {
       zeroesBeforePoint = 1; // "." -> "0."
     }
     int totalLength{signLength + digitsBeforePoint + zeroesBeforePoint +
         1 /*'.'*/ + zeroesAfterPoint + digitsAfterPoint + trailingOnes +
         trailingZeroes};
     int width{editWidth > 0 ? editWidth : totalLength};
     if (totalLength > width) {
-      return io_.EmitRepeated('*', width);
+      return EmitRepeated(io_, '*', width);
     }
     if (totalLength < width && digitsBeforePoint + zeroesBeforePoint == 0) {
       zeroesBeforePoint = 1;
       ++totalLength;
     }
     return EmitPrefix(edit, totalLength, width) &&
-        io_.Emit(converted.str, signLength + digitsBeforePoint) &&
-        io_.EmitRepeated('0', zeroesBeforePoint) &&
-        io_.Emit(edit.modes.editingFlags & decimalComma ? "," : ".", 1) &&
-        io_.EmitRepeated('0', zeroesAfterPoint) &&
-        io_.Emit(
-            converted.str + signLength + digitsBeforePoint, digitsAfterPoint) &&
-        io_.EmitRepeated('1', trailingOnes) &&
-        io_.EmitRepeated('0', trailingZeroes) &&
-        io_.EmitRepeated(' ', trailingBlanks_) && EmitSuffix(edit);
+        EmitAscii(io_, converted.str, signLength + digitsBeforePoint) &&
+        EmitRepeated(io_, '0', zeroesBeforePoint) &&
+        EmitAscii(io_, edit.modes.editingFlags & decimalComma ? "," : ".", 1) &&
+        EmitRepeated(io_, '0', zeroesAfterPoint) &&
+        EmitAscii(io_, converted.str + signLength + digitsBeforePoint,
+            digitsAfterPoint) &&
+        EmitRepeated(io_, '1', trailingOnes) &&
+        EmitRepeated(io_, '0', trailingZeroes) &&
+        EmitRepeated(io_, ' ', trailingBlanks_) && EmitSuffix(edit);
   }
 }
 
 // 13.7.5.2.3 in F'2018
 template <int binaryPrecision>
 DataEdit RealOutputEditing<binaryPrecision>::EditForGOutput(DataEdit edit) {
   edit.descriptor = 'E';
   int editWidth{edit.width.value_or(0)};
io_.GetIoErrorHandler().SignalError(IostatErrorInFormat,
         edit.descriptor);
     return false;
   }
   return false;
 }
 
 bool ListDirectedLogicalOutput(IoStatementState &io,
     ListDirectedStatementState<Direction::Output> &list, bool truth) {
-  return list.EmitLeadingSpaceOrAdvance(io) && io.Emit(truth ? "T" : "F", 1);
+  return list.EmitLeadingSpaceOrAdvance(io) &&
+      EmitAscii(io, truth ? "T" : "F", 1);
 }
 
 bool EditLogicalOutput(IoStatementState &io, const DataEdit &edit, bool truth) {
   switch (edit.descriptor) {
   case 'L':
   case 'G':
-    return io.EmitRepeated(' ', std::max(0, edit.width.value_or(1) - 1)) &&
-        io.Emit(truth ? "T" : "F", 1);
+    return EmitRepeated(io, ' ', std::max(0, edit.width.value_or(1) - 1)) &&
+        EmitAscii(io, truth ? "T" : "F", 1);
   case 'B':
     return EditBOZOutput<1>(io, edit,
         reinterpret_cast<const unsigned char *>(&truth), sizeof truth);
   case 'O':
     return EditBOZOutput<3>(io, edit,
         reinterpret_cast<const unsigned char *>(&truth), sizeof truth);
   case 'Z':
     return EditBOZOutput<4>(io, edit,
bool ListDirectedCharacterOutput(IoStatementState &io,
   if (modes.delim) {
     ok = ok && list.EmitLeadingSpaceOrAdvance(io);
     // Value is delimited with ' or " marks, and interior
     // instances of that character are doubled.
     auto EmitOne{[&](CHAR ch) {
       if (connection.NeedAdvance(1)) {
         ok = ok && io.AdvanceRecord();
       }
-      ok = ok && io.EmitEncoded(&ch, 1);
+      ok = ok && EmitEncoded(io, &ch, 1);
     }};
     EmitOne(modes.delim);
     for (std::size_t j{0}; j < length; ++j) {
       // Doubled delimiters must be put on the same record
       // in order to be acceptable as list-directed or NAMELIST
       // input; however, this requirement is not always possible
       // when the records have a fixed length, as is the case with
       // internal output.  The standard is silent on what should
       // happen, and no two extant Fortran implementations do
       // the same thing when tested with this case.
       // This runtime splits the doubled delimiters across
       // two records for lack of a better alternative.
       if (x[j] == static_cast<CHAR>(modes.delim)) {
         EmitOne(x[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.useUTF8<CHAR>() ? 1 : length};
+    std::size_t oneAtATime{
+        connection.useUTF8<CHAR>() || connection.internalIoCharKind > 1
+            ? 1
+            : length};
     while (ok && put < length) {
       if (std::size_t chunk{std::min<std::size_t>(
-              std::min<std::size_t>(length - put, oneIfUTF8),
+              std::min<std::size_t>(length - put, oneAtATime),
               connection.RemainingSpaceInRecord())}) {
-        ok = io.EmitEncoded(x + put, chunk);
+        ok = EmitEncoded(io, x + put, chunk);
         put += chunk;
       } else {
-        ok = io.AdvanceRecord() && io.Emit(" ", 1);
+        ok = io.AdvanceRecord() && EmitAscii(io, " ", 1);
       }
     }
     list.set_lastWasUndelimitedCharacter(true);
   }
   return ok;
 }
 
 template <typename CHAR>
case 'Z':
     return EditBOZOutput<4>(io, edit,
         reinterpret_cast<const unsigned char *>(x), sizeof(CHAR) * length);
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
         "Data edit descriptor '%c' may not be used with a CHARACTER data item",
         edit.descriptor);
     return false;
   }
-  return io.EmitRepeated(' ', std::max(0, width - len)) &&
-      io.EmitEncoded(x, std::min(width, len));
+  return EmitRepeated(io, ' ', std::max(0, width - len)) &&
+      EmitEncoded(io, x, std::min(width, len));
 }
 
 template bool EditIntegerOutput<1>(
     IoStatementState &, const DataEdit &, std::int8_t);
 template bool EditIntegerOutput<2>(
     IoStatementState &, const DataEdit &, std::int16_t);
 template bool EditIntegerOutput<4>(
     IoStatementState &, const DataEdit &, std::int32_t);

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 "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.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 (at + maxUTF8Bytes > sizeof buffer) {
+        if (!to.Emit(buffer, at)) {
+          return false;
+        }
+        at = 0;
+      }
+    }
+    return at == 0 || to.Emit(buffer, at);
+  } else {
+    std::size_t internalKind = connection.internalIoCharKind;
+    if (internalKind == 0 || internalKind == sizeof(CHAR)) {
+      const char *rawData{reinterpret_cast<const char *>(data)};
+      return to.Emit(rawData, chars * sizeof(CHAR), sizeof(CHAR));
+    } else {
+      // CHARACTER kind conversion for internal output
+      while (chars-- > 0) {
+        char32_t buffer = *data++;
+        char *p{reinterpret_cast<char *>(&buffer)};
+        if constexpr (!isHostLittleEndian) {
+          p += sizeof(buffer) - internalKind;
+        }
+        if (!to.Emit(p, internalKind)) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+}
+
+template <typename CONTEXT>
+bool EmitAscii(CONTEXT &to, const char *data, std::size_t chars) {
+  ConnectionState &connection{to.GetConnectionState()};
+  if (connection.internalIoCharKind <= 1) {
+    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) {
+    while (n-- > 0) {
+      if (!to.Emit(&ch, 1)) {
+        return false;
+      }
+    }
+  } else {
+    while (n-- > 0) {
+      if (!EmitEncoded(to, &ch, 1)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_EMIT_ENCODED_H_

flang/runtime/format-implementation.h

 //===-- runtime/format-implementation.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
 //
 //===----------------------------------------------------------------------===//
 
 // Implements out-of-line member functions of template class FormatControl
 
 #ifndef FORTRAN_RUNTIME_FORMAT_IMPLEMENTATION_H_
 #define FORTRAN_RUNTIME_FORMAT_IMPLEMENTATION_H_
 
+#include "emit-encoded.h"
 #include "format.h"
 #include "io-stmt.h"
 #include "flang/Common/format.h"
 #include "flang/Decimal/decimal.h"
 #include "flang/Runtime/main.h"
 #include <algorithm>
 #include <limits>
 
case 'P':
       modes.round = executionEnvironment.defaultOutputRoundingMode;
       return;
     default:
       break;
     }
     break;
   case 'X':
     if (!next) {
+      ConnectionState &connection{context.GetConnectionState()};
+      if (connection.internalIoCharKind > 1) {
+        n *= connection.internalIoCharKind;
+      }
       context.HandleRelativePosition(n);
       return;
     }
     break;
   case 'S':
     if (next == 'P') {
       modes.editingFlags |= signPlus;
       return;
     }
     if (!next || next == 'S') {
       modes.editingFlags &= ~signPlus;
       return;
     }
     break;
   case 'T': {
     if (!next) { // Tn
-      context.HandleAbsolutePosition(n - 1); // convert 1-based to 0-based
+      --n; // convert 1-based to 0-based
+    }
+    ConnectionState &connection{context.GetConnectionState()};
+    if (connection.internalIoCharKind > 1) {
+      n *= connection.internalIoCharKind;
+    }
+    if (!next) { // Tn
+      context.HandleAbsolutePosition(n);
       return;
     }
     if (next == 'L' || next == 'R') { // TLn & TRn
       context.HandleRelativePosition(next == 'L' ? -n : n);
       return;
     }
   } break;
   default:
if (ch == '(') {
           static_cast<std::size_t>(&format_[offset_] - &format_[start])};
       if (offset_ < formatLength_ && format_[offset_] == quote) {
         // subtle: handle doubled quote character in a literal by including
         // the first in the output, then treating the second as the start
         // of another character literal.
       } else {
         --chars;
       }
-      context.Emit(format_ + start, chars);
+      EmitAscii(context, format_ + start, chars);
     } else if (ch == 'H') {
       // 9HHOLLERITH
       if (!repeat || *repeat < 1 || offset_ + *repeat > formatLength_) {
         ReportBadFormat(context, "Invalid width on Hollerith in FORMAT",
             maybeReversionPoint);
         return 0;
       }
-      context.Emit(format_ + offset_, static_cast<std::size_t>(*repeat));
+      EmitAscii(context, format_ + offset_, static_cast<std::size_t>(*repeat));
       offset_ += *repeat;
     } else if (ch >= 'A' && ch <= 'Z') {
       int start{offset_ - 1};
       CharType next{'\0'};
       if (ch != 'P') { // 1PE5.2 - comma not required (C1302)
         CharType peek{Capitalize(PeekNext())};
         if (peek >= 'A' && peek <= 'Z') {
           if (ch == 'A' /* anticipate F'202X AT editing */ || ch == 'B' ||
if (ch == '(') {
       }
     } else if (ch == '/') {
       context.AdvanceRecord(repeat && *repeat > 0 ? *repeat : 1);
     } else if (ch == '$' || ch == '\\') {
       context.mutableModes().nonAdvancing = true;
     } else if (ch == '\t' || ch == '\v') {
       // Tabs (extension)
       // TODO: any other raw characters?
-      context.Emit(format_ + offset_ - 1, 1);
+      EmitAscii(context, format_ + offset_ - 1, 1);
     } else {
       ReportBadFormat(
           context, "Invalid character in FORMAT", maybeReversionPoint);
       return 0;
     }
   }
 }
 

flang/runtime/format.h

 #include "io-error.h"
 #include "flang/Common/Fortran.h"
 #include "flang/Decimal/decimal.h"
 #include <cinttypes>
 #include <optional>
 
 namespace Fortran::runtime::io {
 
+class IoStatementState;
+
 enum EditingFlags {
   blankZero = 1, // BLANK=ZERO or BZ edit
   decimalComma = 2, // DECIMAL=COMMA or DC edit
   signPlus = 4, // SIGN=PLUS or SP edit
 };
 
 struct MutableModes {
   std::uint8_t editingFlags{0}; // BN, DP, SS

 };
 
 // Generates a sequence of DataEdits from a FORMAT statement or
 // default-CHARACTER string.  Driven by I/O item list processing.
 // Errors are fatal.  See subclause 13.4 in Fortran 2018 for background.
 template <typename CONTEXT> class FormatControl {
 public:
   using Context = CONTEXT;
-  using CharType = typename Context::CharType;
+  using CharType = char; // formats are always default kind CHARACTER
 
   FormatControl() {}
   FormatControl(const Terminator &, const CharType *format,
       std::size_t formatLength, int maxHeight = maxMaxHeight);
 
   // For attempting to allocate in a user-supplied stack area
   static std::size_t GetNeededSize(int maxHeight) {
     return sizeof(FormatControl) -

flang/runtime/internal-unit.h

 class IoErrorHandler;
 
 // Points to (but does not own) a CHARACTER scalar or array for internal I/O.
 // Does not buffer.
 template <Direction DIR> class InternalDescriptorUnit : public ConnectionState {
 public:
   using Scalar =
       std::conditional_t<DIR == Direction::Input, const char *, char *>;
-  InternalDescriptorUnit(Scalar, std::size_t);
+  InternalDescriptorUnit(Scalar, std::size_t chars, int kind);
   InternalDescriptorUnit(const Descriptor &, const Terminator &);
   void EndIoStatement();
 
   bool Emit(const char *, std::size_t, IoErrorHandler &);
   std::size_t GetNextInputBytes(const char *&, IoErrorHandler &);
   bool AdvanceRecord(IoErrorHandler &);
   void BackspaceRecord(IoErrorHandler &);
 
 private:
   Descriptor &descriptor() { return staticDescriptor_.descriptor(); }
   const Descriptor &descriptor() const {
     return staticDescriptor_.descriptor();
   }
   Scalar CurrentRecord() const {
     return descriptor().template ZeroBasedIndexedElement<char>(
         currentRecordNumber - 1);
   }
+  void BlankFill(char *, std::size_t);
   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

 #include "flang/Runtime/descriptor.h"
 #include <algorithm>
 #include <type_traits>
 
 namespace Fortran::runtime::io {
 
 template <Direction DIR>
 InternalDescriptorUnit<DIR>::InternalDescriptorUnit(
-    Scalar scalar, std::size_t length) {
+    Scalar scalar, std::size_t length, int kind) {
+  internalIoCharKind = kind;
   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);
+  descriptor().Establish(TypeCode{TypeCategory::Character, kind}, length * kind,
+      pointer, 0, nullptr, CFI_attribute_pointer);
 }
 
 template <Direction DIR>
 InternalDescriptorUnit<DIR>::InternalDescriptorUnit(
     const Descriptor &that, const Terminator &terminator) {
-  RUNTIME_CHECK(terminator, that.type().IsCharacter());
+  auto thatType{that.type().GetCategoryAndKind()};
+  RUNTIME_CHECK(terminator, thatType.has_value());
+  RUNTIME_CHECK(terminator, thatType->first == TypeCategory::Character);
   Descriptor &d{descriptor()};
   RUNTIME_CHECK(
       terminator, that.SizeInBytes() <= d.SizeInBytes(maxRank, true, 0));
   new (&d) Descriptor{that};
   d.Check();
+  internalIoCharKind = thatType->second;
   recordLength = d.ElementBytes();
   endfileRecordNumber = d.Elements() + 1;
 }
 
 template <Direction DIR> void InternalDescriptorUnit<DIR>::EndIoStatement() {
   if constexpr (DIR == Direction::Output) {
     // Clear the remainder of the current record if anything was written
     // to it, or if it is the only record.
auto furthestAfter{std::max(furthestPositionInRecord,
         positionInRecord + static_cast<std::int64_t>(bytes))};
     bool ok{true};
     if (furthestAfter > static_cast<std::int64_t>(recordLength.value_or(0))) {
       handler.SignalError(IostatRecordWriteOverrun);
       furthestAfter = recordLength.value_or(0);
       bytes = std::max(std::int64_t{0}, furthestAfter - positionInRecord);
       ok = false;
     } else if (positionInRecord > furthestPositionInRecord) {
-      std::fill_n(record + furthestPositionInRecord,
-          positionInRecord - furthestPositionInRecord, ' ');
+      BlankFill(record + furthestPositionInRecord,
+          positionInRecord - furthestPositionInRecord);
     }
     std::memcpy(record + positionInRecord, data, bytes);
     positionInRecord += bytes;
     furthestPositionInRecord = furthestAfter;
     return ok;
   }
 }
 
if constexpr (DIR == Direction::Output) {
     BlankFillOutputRecord();
   }
   ++currentRecordNumber;
   BeginRecord();
   return true;
 }
 
 template <Direction DIR>
+void InternalDescriptorUnit<DIR>::BlankFill(char *at, std::size_t bytes) {
+  switch (internalIoCharKind) {
+  case 2:
+    std::fill_n(reinterpret_cast<char16_t *>(at), bytes / 2,
+        static_cast<char16_t>(' '));
+    break;
+  case 4:
+    std::fill_n(reinterpret_cast<char32_t *>(at), bytes / 4,
+        static_cast<char32_t>(' '));
+    break;
+  default:
+    std::fill_n(at, bytes, ' ');
+    break;
+  }
+}
+
+template <Direction DIR>
 void InternalDescriptorUnit<DIR>::BlankFillOutputRecord() {
   if constexpr (DIR == Direction::Output) {
     if (furthestPositionInRecord <
         recordLength.value_or(furthestPositionInRecord)) {
-      char *record{CurrentRecord()};
-      std::fill_n(record + furthestPositionInRecord,
-          *recordLength - furthestPositionInRecord, ' ');
+      BlankFill(CurrentRecord() + furthestPositionInRecord,
+          *recordLength - furthestPositionInRecord);
     }
   }
 }
 
 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/runtime/io-stmt.h

 class InquireIOLengthState;
 class ExternalMiscIoStatementState;
 class CloseStatementState;
 class NoopStatementState; // CLOSE or FLUSH on unknown unit
 class ErroneousIoStatementState;
 
 template <Direction, typename CHAR = char>
 class InternalFormattedIoStatementState;
-template <Direction, typename CHAR = char> class InternalListIoStatementState;
+template <Direction> class InternalListIoStatementState;
 template <Direction, typename CHAR = char>
 class ExternalFormattedIoStatementState;
 template <Direction> class ExternalListIoStatementState;
 template <Direction> class ExternalUnformattedIoStatementState;
 template <Direction, typename CHAR = char> class ChildFormattedIoStatementState;
 template <Direction> class ChildListIoStatementState;
 template <Direction> class ChildUnformattedIoStatementState;
 
public:
   // CompleteOperation() is the last opportunity to raise an I/O error.
   // It is called by EndIoStatement(), but it can be invoked earlier to
   // catch errors for (e.g.) GetIoMsg() and GetNewUnit().  If called
   // more than once, it is a no-op.
   void CompleteOperation();
   // Completes an I/O statement and reclaims storage.
   int EndIoStatement();
 
-  bool Emit(const char *, std::size_t, std::size_t elementBytes);
-  bool Emit(const char *, std::size_t);
-  bool Emit(const char16_t *, std::size_t chars);
-  bool Emit(const char32_t *, std::size_t chars);
-  template <typename CHAR> bool EmitEncoded(const CHAR *, std::size_t);
+  bool Emit(const char *, std::size_t bytes, std::size_t elementBytes = 0);
   bool Receive(char *, std::size_t, std::size_t elementBytes = 0);
   std::size_t GetNextInputBytes(const char *&);
   bool AdvanceRecord(int = 1);
   void BackspaceRecord();
   void HandleRelativePosition(std::int64_t);
   void HandleAbsolutePosition(std::int64_t); // for r* in list I/O
   std::optional<DataEdit> GetNextDataEdit(int maxRepeat = 1);
   ExternalFileUnit *GetExternalFileUnit() const; // null if internal unit
return common::visit(
           return nullptr;
         },
         u_);
   }
 
   // Vacant after the end of the current record
   std::optional<char32_t> GetCurrentChar(std::size_t &byteCount);
 
-  bool EmitRepeated(char, std::size_t);
-  bool EmitField(const char *, std::size_t length, std::size_t width);
-
-  // For fixed-width fields, initialize the number of remaining characters.
-  // Skip over leading blanks, then return the first non-blank character (if
-  // any).
-  std::optional<char32_t> PrepareInput(
-      const DataEdit &edit, std::optional<int> &remaining) {
-    remaining.reset();
+  // For fixed-width fields, return the number of remaining characters.
+  // Skip over leading blanks.
+  std::optional<int> CueUpInput(const DataEdit &edit) {
+    std::optional<int> remaining;
     if (edit.IsListDirected()) {
       std::size_t byteCount{0};
       GetNextNonBlank(byteCount);
     } else {
       if (edit.width.value_or(0) > 0) {
         remaining = *edit.width;
       }
       SkipSpaces(remaining);
     }
-    return NextInField(remaining, edit);
+    return remaining;
   }
 
   std::optional<char32_t> SkipSpaces(std::optional<int> &remaining) {
     while (!remaining || *remaining > 0) {
       std::size_t byteCount{0};
       if (auto ch{GetCurrentChar(byteCount)}) {
         if (*ch != ' ' && *ch != '\t') {
           return ch;
public:
   using IoErrorHandler::IoErrorHandler;
 
   bool completedOperation() const { return completedOperation_; }
 
   void CompleteOperation() { completedOperation_ = true; }
   int EndIoStatement() { return GetIoStat(); }
 
   // These are default no-op backstops that can be overridden by descendants.
-  bool Emit(const char *, std::size_t, std::size_t elementBytes);
-  bool Emit(const char *, std::size_t);
-  bool Emit(const char16_t *, std::size_t chars);
-  bool Emit(const char32_t *, std::size_t chars);
-  bool Receive(char *, std::size_t, std::size_t elementBytes = 0);
+  bool Emit(const char *, std::size_t bytes, std::size_t elementBytes = 0);
+  bool Receive(char *, std::size_t bytes, std::size_t elementBytes = 0);
   std::size_t GetNextInputBytes(const char *&);
   bool AdvanceRecord(int);
   void BackspaceRecord();
   void HandleRelativePosition(std::int64_t);
   void HandleAbsolutePosition(std::int64_t);
   std::optional<DataEdit> GetNextDataEdit(
       IoStatementState &, int maxRepeat = 1);
   ExternalFileUnit *GetExternalFileUnit() const;
private:
   int remaining_{0}; // for "r*" repetition
   std::optional<SavedPosition> repeatPosition_;
   bool eatComma_{false}; // consume comma after previously read item
   bool hitSlash_{false}; // once '/' is seen, nullify further items
   bool realPart_{false};
   bool imaginaryPart_{false};
 };
 
-template <Direction DIR, typename CHAR = char>
+template <Direction DIR>
 class InternalIoStatementState : public IoStatementBase,
                                  public IoDirectionState<DIR> {
 public:
-  using CharType = CHAR;
   using Buffer =
-      std::conditional_t<DIR == Direction::Input, const CharType *, CharType *>;
+      std::conditional_t<DIR == Direction::Input, const char *, char *>;
   InternalIoStatementState(Buffer, std::size_t,
       const char *sourceFile = nullptr, int sourceLine = 0);
   InternalIoStatementState(
       const Descriptor &, const char *sourceFile = nullptr, int sourceLine = 0);
   int EndIoStatement();
 
-  using IoStatementBase::Emit;
-  bool Emit(
-      const CharType *data, std::size_t chars /* not necessarily bytes */);
+  bool Emit(const char *data, std::size_t bytes, std::size_t elementBytes = 0);
   std::size_t GetNextInputBytes(const char *&);
   bool AdvanceRecord(int = 1);
   void BackspaceRecord();
   ConnectionState &GetConnectionState() { return unit_; }
   MutableModes &mutableModes() { return unit_.modes; }
   void HandleRelativePosition(std::int64_t);
   void HandleAbsolutePosition(std::int64_t);
 
 protected:
   bool free_{true};
   InternalDescriptorUnit<DIR> unit_;
 };
 
 template <Direction DIR, typename CHAR>
 class InternalFormattedIoStatementState
-    : public InternalIoStatementState<DIR, CHAR>,
+    : public InternalIoStatementState<DIR>,
       public FormattedIoStatementState<DIR> {
 public:
   using CharType = CHAR;
-  using typename InternalIoStatementState<DIR, CharType>::Buffer;
+  using typename InternalIoStatementState<DIR>::Buffer;
   InternalFormattedIoStatementState(Buffer internal, std::size_t internalLength,
       const CharType *format, std::size_t formatLength,
       const char *sourceFile = nullptr, int sourceLine = 0);
   InternalFormattedIoStatementState(const Descriptor &, const CharType *format,
       std::size_t formatLength, const char *sourceFile = nullptr,
       int sourceLine = 0);
   IoStatementState &ioStatementState() { return ioStatementState_; }
   void CompleteOperation();
   int EndIoStatement();
   std::optional<DataEdit> GetNextDataEdit(
       IoStatementState &, int maxRepeat = 1) {
     return format_.GetNextDataEdit(*this, maxRepeat);
   }
 
 private:
   IoStatementState ioStatementState_; // points to *this
-  using InternalIoStatementState<DIR, CharType>::unit_;
+  using InternalIoStatementState<DIR>::unit_;
   // format_ *must* be last; it may be partial someday
   FormatControl<InternalFormattedIoStatementState> format_;
 };
 
-template <Direction DIR, typename CHAR>
-class InternalListIoStatementState : public InternalIoStatementState<DIR, CHAR>,
+template <Direction DIR>
+class InternalListIoStatementState : public InternalIoStatementState<DIR>,
                                      public ListDirectedStatementState<DIR> {
 public:
-  using CharType = CHAR;
-  using typename InternalIoStatementState<DIR, CharType>::Buffer;
+  using typename InternalIoStatementState<DIR>::Buffer;
   InternalListIoStatementState(Buffer internal, std::size_t internalLength,
       const char *sourceFile = nullptr, int sourceLine = 0);
   InternalListIoStatementState(
       const Descriptor &, const char *sourceFile = nullptr, int sourceLine = 0);
   IoStatementState &ioStatementState() { return ioStatementState_; }
   using ListDirectedStatementState<DIR>::GetNextDataEdit;
 
 private:
   IoStatementState ioStatementState_; // points to *this
-  using InternalIoStatementState<DIR, CharType>::unit_;
+  using InternalIoStatementState<DIR>::unit_;
 };
 
 class ExternalIoStatementBase : public IoStatementBase {
 public:
   ExternalIoStatementBase(
       ExternalFileUnit &, const char *sourceFile = nullptr, int sourceLine = 0);
   ExternalFileUnit &unit() { return unit_; }
   MutableModes &mutableModes();

 class ExternalIoStatementState : public ExternalIoStatementBase,
                                  public IoDirectionState<DIR> {
 public:
   ExternalIoStatementState(
       ExternalFileUnit &, const char *sourceFile = nullptr, int sourceLine = 0);
   MutableModes &mutableModes() { return mutableModes_; }
   void CompleteOperation();
   int EndIoStatement();
-  bool Emit(const char *, std::size_t, std::size_t elementBytes);
-  bool Emit(const char *, std::size_t);
-  bool Emit(const char16_t *, std::size_t chars /* not bytes */);
-  bool Emit(const char32_t *, std::size_t chars /* not bytes */);
+  bool Emit(const char *, std::size_t bytes, std::size_t elementBytes = 0);
   std::size_t GetNextInputBytes(const char *&);
   bool AdvanceRecord(int = 1);
   void BackspaceRecord();
   void HandleRelativePosition(std::int64_t);
   void HandleAbsolutePosition(std::int64_t);
   bool BeginReadingRecord();
   void FinishReadingRecord();
 
public:
   ChildIoStatementState(
       ChildIo &, const char *sourceFile = nullptr, int sourceLine = 0);
   ChildIo &child() { return child_; }
   MutableModes &mutableModes();
   ConnectionState &GetConnectionState();
   ExternalFileUnit *GetExternalFileUnit() const;
   void CompleteOperation();
   int EndIoStatement();
-  bool Emit(const char *, std::size_t, std::size_t elementBytes);
-  bool Emit(const char *, std::size_t);
-  bool Emit(const char16_t *, std::size_t chars /* not bytes */);
-  bool Emit(const char32_t *, std::size_t chars /* not bytes */);
+  bool Emit(const char *, std::size_t bytes, std::size_t elementBytes = 0);
   std::size_t GetNextInputBytes(const char *&);
   void HandleRelativePosition(std::int64_t);
   void HandleAbsolutePosition(std::int64_t);
 
 private:
   ChildIo &child_;
 };
 
private:
   OwningPtr<char> path_; // trimmed and NUL terminated
 };
 
 class InquireIOLengthState : public NoUnitIoStatementState,
                              public OutputStatementState {
 public:
   InquireIOLengthState(const char *sourceFile = nullptr, int sourceLine = 0);
   std::size_t bytes() const { return bytes_; }
-  bool Emit(const char *, std::size_t, std::size_t elementBytes);
-  bool Emit(const char *, std::size_t);
-  bool Emit(const char16_t *, std::size_t chars);
-  bool Emit(const char32_t *, std::size_t chars);
+  bool Emit(const char *, std::size_t bytes, std::size_t elementBytes = 0);
 
 private:
   std::size_t bytes_{0};
 };
 
 class ExternalMiscIoStatementState : public ExternalIoStatementBase {
 public:
   enum Which { Flush, Backspace, Endfile, Rewind, Wait };
public:
   ConnectionState &GetConnectionState() { return connection_; }
   MutableModes &mutableModes() { return connection_.modes; }
 
 private:
   ConnectionState connection_;
   ExternalFileUnit *unit_{nullptr};
 };
 
-extern template bool IoStatementState::EmitEncoded<char>(
-    const char *, std::size_t);
-extern template bool IoStatementState::EmitEncoded<char16_t>(
-    const char16_t *, std::size_t);
-extern template bool IoStatementState::EmitEncoded<char32_t>(
-    const char32_t *, std::size_t);
-
 } // namespace Fortran::runtime::io
 #endif // FORTRAN_RUNTIME_IO_STMT_H_

flang/runtime/io-stmt.cpp

 //===-- runtime/io-stmt.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 "io-stmt.h"
 #include "connection.h"
+#include "emit-encoded.h"
 #include "format.h"
 #include "tools.h"
 #include "unit.h"
 #include "utf.h"
 #include "flang/Runtime/memory.h"
 #include <algorithm>
 #include <cstdio>
 #include <cstring>
 #include <limits>
 #include <type_traits>
 
 namespace Fortran::runtime::io {
 
 bool IoStatementBase::Emit(const char *, std::size_t, std::size_t) {
   return false;
 }
 
-bool IoStatementBase::Emit(const char *, std::size_t) { return false; }
-
-bool IoStatementBase::Emit(const char16_t *, std::size_t) { return false; }
-
-bool IoStatementBase::Emit(const char32_t *, std::size_t) { return false; }
-
 std::size_t IoStatementBase::GetNextInputBytes(const char *&p) {
   p = nullptr;
   return 0;
 }
 
 bool IoStatementBase::AdvanceRecord(int) { return false; }
 
 void IoStatementBase::BackspaceRecord() {}

 
 void IoStatementBase::BadInquiryKeywordHashCrash(InquiryKeywordHash inquiry) {
   char buffer[16];
   const char *decode{InquiryKeywordHashDecode(buffer, sizeof buffer, inquiry)};
   Crash("Bad InquiryKeywordHash 0x%x (%s)", inquiry,
       decode ? decode : "(cannot decode)");
 }
 
-template <Direction DIR, typename CHAR>
-InternalIoStatementState<DIR, CHAR>::InternalIoStatementState(
+template <Direction DIR>
+InternalIoStatementState<DIR>::InternalIoStatementState(
     Buffer scalar, std::size_t length, const char *sourceFile, int sourceLine)
-    : IoStatementBase{sourceFile, sourceLine}, unit_{scalar, length} {}
+    : IoStatementBase{sourceFile, sourceLine}, unit_{scalar, length, 1} {}
 
-template <Direction DIR, typename CHAR>
-InternalIoStatementState<DIR, CHAR>::InternalIoStatementState(
+template <Direction DIR>
+InternalIoStatementState<DIR>::InternalIoStatementState(
     const Descriptor &d, const char *sourceFile, int sourceLine)
     : IoStatementBase{sourceFile, sourceLine}, unit_{d, *this} {}
 
-template <Direction DIR, typename CHAR>
-bool InternalIoStatementState<DIR, CHAR>::Emit(
-    const CharType *data, std::size_t chars) {
+template <Direction DIR>
+bool InternalIoStatementState<DIR>::Emit(
+    const char *data, std::size_t bytes, std::size_t /*elementBytes*/) {
   if constexpr (DIR == Direction::Input) {
     Crash("InternalIoStatementState<Direction::Input>::Emit() called");
     return false;
   }
-  return unit_.Emit(data, chars * sizeof(CharType), *this);
+  return unit_.Emit(data, bytes, *this);
 }
 
-template <Direction DIR, typename CHAR>
-std::size_t InternalIoStatementState<DIR, CHAR>::GetNextInputBytes(
-    const char *&p) {
+template <Direction DIR>
+std::size_t InternalIoStatementState<DIR>::GetNextInputBytes(const char *&p) {
   return unit_.GetNextInputBytes(p, *this);
 }
 
-template <Direction DIR, typename CHAR>
-bool InternalIoStatementState<DIR, CHAR>::AdvanceRecord(int n) {
+template <Direction DIR>
+bool InternalIoStatementState<DIR>::AdvanceRecord(int n) {
   while (n-- > 0) {
     if (!unit_.AdvanceRecord(*this)) {
       return false;
     }
   }
   return true;
 }
 
-template <Direction DIR, typename CHAR>
-void InternalIoStatementState<DIR, CHAR>::BackspaceRecord() {
+template <Direction DIR> void InternalIoStatementState<DIR>::BackspaceRecord() {
   unit_.BackspaceRecord(*this);
 }
 
-template <Direction DIR, typename CHAR>
-int InternalIoStatementState<DIR, CHAR>::EndIoStatement() {
+template <Direction DIR> int InternalIoStatementState<DIR>::EndIoStatement() {
   if constexpr (DIR == Direction::Output) {
     unit_.EndIoStatement(); // fill
   }
   auto result{IoStatementBase::EndIoStatement()};
   if (free_) {
     FreeMemory(this);
   }
   return result;
 }
 
-template <Direction DIR, typename CHAR>
-void InternalIoStatementState<DIR, CHAR>::HandleAbsolutePosition(
-    std::int64_t n) {
+template <Direction DIR>
+void InternalIoStatementState<DIR>::HandleAbsolutePosition(std::int64_t n) {
   return unit_.HandleAbsolutePosition(n);
 }
 
-template <Direction DIR, typename CHAR>
-void InternalIoStatementState<DIR, CHAR>::HandleRelativePosition(
-    std::int64_t n) {
+template <Direction DIR>
+void InternalIoStatementState<DIR>::HandleRelativePosition(std::int64_t n) {
   return unit_.HandleRelativePosition(n);
 }
 
 template <Direction DIR, typename CHAR>
 InternalFormattedIoStatementState<DIR, CHAR>::InternalFormattedIoStatementState(
-    Buffer buffer, std::size_t length, const CHAR *format,
+    Buffer buffer, std::size_t length, const CharType *format,
     std::size_t formatLength, const char *sourceFile, int sourceLine)
-    : InternalIoStatementState<DIR, CHAR>{buffer, length, sourceFile,
-          sourceLine},
+    : InternalIoStatementState<DIR>{buffer, length, sourceFile, sourceLine},
       ioStatementState_{*this}, format_{*this, format, formatLength} {}
 
 template <Direction DIR, typename CHAR>
 InternalFormattedIoStatementState<DIR, CHAR>::InternalFormattedIoStatementState(
-    const Descriptor &d, const CHAR *format, std::size_t formatLength,
+    const Descriptor &d, const CharType *format, std::size_t formatLength,
     const char *sourceFile, int sourceLine)
-    : InternalIoStatementState<DIR, CHAR>{d, sourceFile, sourceLine},
+    : InternalIoStatementState<DIR>{d, sourceFile, sourceLine},
       ioStatementState_{*this}, format_{*this, format, formatLength} {}
 
 template <Direction DIR, typename CHAR>
 void InternalFormattedIoStatementState<DIR, CHAR>::CompleteOperation() {
   if (!this->completedOperation()) {
     if constexpr (DIR == Direction::Output) {
       format_.Finish(*this); // ignore any remaining input positioning actions
     }
     IoStatementBase::CompleteOperation();
   }
 }
 
 template <Direction DIR, typename CHAR>
 int InternalFormattedIoStatementState<DIR, CHAR>::EndIoStatement() {
   CompleteOperation();
-  return InternalIoStatementState<DIR, CHAR>::EndIoStatement();
+  return InternalIoStatementState<DIR>::EndIoStatement();
 }
 
-template <Direction DIR, typename CHAR>
-InternalListIoStatementState<DIR, CHAR>::InternalListIoStatementState(
+template <Direction DIR>
+InternalListIoStatementState<DIR>::InternalListIoStatementState(
     Buffer buffer, std::size_t length, const char *sourceFile, int sourceLine)
-    : InternalIoStatementState<DIR, CharType>{buffer, length, sourceFile,
-          sourceLine},
+    : InternalIoStatementState<DIR>{buffer, length, sourceFile, sourceLine},
       ioStatementState_{*this} {}
 
-template <Direction DIR, typename CHAR>
-InternalListIoStatementState<DIR, CHAR>::InternalListIoStatementState(
+template <Direction DIR>
+InternalListIoStatementState<DIR>::InternalListIoStatementState(
     const Descriptor &d, const char *sourceFile, int sourceLine)
-    : InternalIoStatementState<DIR, CharType>{d, sourceFile, sourceLine},
+    : InternalIoStatementState<DIR>{d, sourceFile, sourceLine},
       ioStatementState_{*this} {}
 
 ExternalIoStatementBase::ExternalIoStatementBase(
     ExternalFileUnit &unit, const char *sourceFile, int sourceLine)
     : IoStatementBase{sourceFile, sourceLine}, unit_{unit} {}
 
 MutableModes &ExternalIoStatementBase::mutableModes() { return unit_.modes; }
 
bool ExternalIoStatementState<DIR>::Emit(
     const char *data, std::size_t bytes, std::size_t elementBytes) {
   if constexpr (DIR == Direction::Input) {
     Crash("ExternalIoStatementState::Emit(char) called for input statement");
   }
   return unit().Emit(data, bytes, elementBytes, *this);
 }
 
 template <Direction DIR>
-bool ExternalIoStatementState<DIR>::Emit(const char *data, std::size_t bytes) {
-  if constexpr (DIR == Direction::Input) {
-    Crash("ExternalIoStatementState::Emit(char) called for input statement");
-  }
-  return unit().Emit(data, bytes, 0, *this);
-}
-
-template <Direction DIR>
-bool ExternalIoStatementState<DIR>::Emit(
-    const char16_t *data, std::size_t chars) {
-  if constexpr (DIR == Direction::Input) {
-    Crash(
-        "ExternalIoStatementState::Emit(char16_t) called for input statement");
-  }
-  return unit().Emit(reinterpret_cast<const char *>(data), chars * sizeof *data,
-      sizeof *data, *this);
-}
-
-template <Direction DIR>
-bool ExternalIoStatementState<DIR>::Emit(
-    const char32_t *data, std::size_t chars) {
-  if constexpr (DIR == Direction::Input) {
-    Crash(
-        "ExternalIoStatementState::Emit(char32_t) called for input statement");
-  }
-  return unit().Emit(reinterpret_cast<const char *>(data), chars * sizeof *data,
-      sizeof *data, *this);
-}
-
-template <Direction DIR>
 std::size_t ExternalIoStatementState<DIR>::GetNextInputBytes(const char *&p) {
   return unit().GetNextInputBytes(p, *this);
 }
 
 template <Direction DIR>
 bool ExternalIoStatementState<DIR>::AdvanceRecord(int n) {
   while (n-- > 0) {
     if (!unit().AdvanceRecord(*this)) {

 }
 
 std::optional<DataEdit> IoStatementState::GetNextDataEdit(int n) {
   return common::visit(
       [&](auto &x) { return x.get().GetNextDataEdit(*this, n); }, u_);
 }
 
 bool IoStatementState::Emit(
-    const char *data, std::size_t n, std::size_t elementBytes) {
+    const char *data, std::size_t bytes, std::size_t elementBytes) {
   return common::visit(
-      [=](auto &x) { return x.get().Emit(data, n, elementBytes); }, u_);
-}
-
-bool IoStatementState::Emit(const char *data, std::size_t n) {
-  return common::visit([=](auto &x) { return x.get().Emit(data, n); }, u_);
-}
-
-bool IoStatementState::Emit(const char16_t *data, std::size_t chars) {
-  return common::visit([=](auto &x) { return x.get().Emit(data, chars); }, u_);
-}
-
-bool IoStatementState::Emit(const char32_t *data, std::size_t chars) {
-  return common::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().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;
-        }
-        at = 0;
-      }
-    }
-    return at == 0 || Emit(buffer, at);
-  } else {
-    return Emit(data0, chars);
-  }
+      [=](auto &x) { return x.get().Emit(data, bytes, elementBytes); }, u_);
 }
 
 bool IoStatementState::Receive(
     char *data, std::size_t n, std::size_t elementBytes) {
   return common::visit(
       [=](auto &x) { return x.get().Receive(data, n, elementBytes); }, u_);
 }
 
void IoStatementState::HandleRelativePosition(std::int64_t n) {
   common::visit([=](auto &x) { x.get().HandleRelativePosition(n); }, u_);
 }
 
 void IoStatementState::HandleAbsolutePosition(std::int64_t n) {
   common::visit([=](auto &x) { x.get().HandleAbsolutePosition(n); }, u_);
 }
 
 void IoStatementState::CompleteOperation() {
-  common::visit([](auto &x) { x.get().CompleteOperation(); }, u_);
+  common::visit([this](auto &x) { x.get().CompleteOperation(); }, u_);
 }
 
 int IoStatementState::EndIoStatement() {
-  return common::visit([](auto &x) { return x.get().EndIoStatement(); }, u_);
+  return common::visit(
+      [this](auto &x) { return x.get().EndIoStatement(); }, u_);
 }
 
 ConnectionState &IoStatementState::GetConnectionState() {
   return common::visit(
       [](auto &x) -> ConnectionState & { return x.get().GetConnectionState(); },
       u_);
 }
 

 std::optional<char32_t> IoStatementState::GetCurrentChar(
     std::size_t &byteCount) {
   const char *p{nullptr};
   std::size_t bytes{GetNextInputBytes(p)};
   if (bytes == 0) {
     byteCount = 0;
     return std::nullopt;
   } else {
-    if (GetConnectionState().isUTF8) {
+    const ConnectionState &connection{GetConnectionState()};
+    if (connection.isUTF8) {
       std::size_t length{MeasureUTF8Bytes(*p)};
       if (length <= bytes) {
         if (auto result{DecodeUTF8(p)}) {
           byteCount = length;
           return result;
         }
       }
       GetIoErrorHandler().SignalError(IostatUTF8Decoding);
       // Error recovery: return the next byte
+    } else if (connection.internalIoCharKind > 1) {
+      byteCount = connection.internalIoCharKind;
+      if (byteCount == 2) {
+        return *reinterpret_cast<const char16_t *>(p);
+      } else {
+        return *reinterpret_cast<const char32_t *>(p);
+      }
     }
     byteCount = 1;
     return *p;
   }
 }
 
-bool IoStatementState::EmitRepeated(char ch, std::size_t n) {
-  return common::visit(
-      [=](auto &x) {
-        for (std::size_t j{0}; j < n; ++j) {
-          if (!x.get().Emit(&ch, 1)) {
-            return false;
-          }
-        }
-        return true;
-      },
-      u_);
-}
-
-bool IoStatementState::EmitField(
-    const char *p, std::size_t length, std::size_t width) {
-  if (width <= 0) {
-    width = static_cast<int>(length);
-  }
-  if (length > static_cast<std::size_t>(width)) {
-    return EmitRepeated('*', width);
-  } else {
-    return EmitRepeated(' ', static_cast<int>(width - length)) &&
-        Emit(p, length);
-  }
-}
-
 std::optional<char32_t> IoStatementState::NextInField(
     std::optional<int> &remaining, const DataEdit &edit) {
   std::size_t byteCount{0};
   if (!remaining) { // Stream, list-directed, or NAMELIST
     if (auto next{GetCurrentChar(byteCount)}) {
       if (edit.IsListDirected()) {
         // list-directed or NAMELIST: check for separators
         switch (*next) {
bool ListDirectedStatementState<Direction::Output>::EmitLeadingSpaceOrAdvance(
   const ConnectionState &connection{io.GetConnectionState()};
   int space{connection.positionInRecord == 0 ||
       !(isCharacter && lastWasUndelimitedCharacter())};
   set_lastWasUndelimitedCharacter(false);
   if (connection.NeedAdvance(space + length)) {
     return io.AdvanceRecord();
   }
   if (space) {
-    return io.Emit(" ", 1);
+    return EmitAscii(io, " ", 1);
   }
   return true;
 }
 
 std::optional<DataEdit>
 ListDirectedStatementState<Direction::Output>::GetNextDataEdit(
     IoStatementState &io, int maxRepeat) {
   DataEdit edit;

 
 template <Direction DIR>
 bool ChildIoStatementState<DIR>::Emit(
     const char *data, std::size_t bytes, std::size_t elementBytes) {
   return child_.parent().Emit(data, bytes, elementBytes);
 }
 
 template <Direction DIR>
-bool ChildIoStatementState<DIR>::Emit(const char *data, std::size_t bytes) {
-  return child_.parent().Emit(data, bytes);
-}
-
-template <Direction DIR>
-bool ChildIoStatementState<DIR>::Emit(const char16_t *data, std::size_t chars) {
-  return child_.parent().Emit(data, chars);
-}
-
-template <Direction DIR>
-bool ChildIoStatementState<DIR>::Emit(const char32_t *data, std::size_t chars) {
-  return child_.parent().Emit(data, chars);
-}
-
-template <Direction DIR>
 std::size_t ChildIoStatementState<DIR>::GetNextInputBytes(const char *&p) {
   return child_.parent().GetNextInputBytes(p);
 }
 
 template <Direction DIR>
 void ChildIoStatementState<DIR>::HandleAbsolutePosition(std::int64_t n) {
   return child_.parent().HandleAbsolutePosition(n);
 }
default:
     return false;
   }
 }
 
 InquireIOLengthState::InquireIOLengthState(
     const char *sourceFile, int sourceLine)
     : NoUnitIoStatementState{*this, sourceFile, sourceLine} {}
 
-bool InquireIOLengthState::Emit(const char *, std::size_t n, std::size_t) {
-  bytes_ += n;
-  return true;
-}
-
-bool InquireIOLengthState::Emit(const char *p, std::size_t n) {
-  bytes_ += sizeof *p * n;
-  return true;
-}
-
-bool InquireIOLengthState::Emit(const char16_t *p, std::size_t n) {
-  bytes_ += sizeof *p * n;
-  return true;
-}
-
-bool InquireIOLengthState::Emit(const char32_t *p, std::size_t n) {
-  bytes_ += sizeof *p * n;
+bool InquireIOLengthState::Emit(const char *, std::size_t bytes, std::size_t) {
+  bytes_ += bytes;
   return true;
 }
 
 int ErroneousIoStatementState::EndIoStatement() {
   SignalPendingError();
   if (unit_) {
     unit_->EndIoStatement();
   }
   return IoStatementBase::EndIoStatement();
 }
 
-template bool IoStatementState::EmitEncoded<char>(const char *, std::size_t);
-template bool IoStatementState::EmitEncoded<char16_t>(
-    const char16_t *, std::size_t);
-template bool IoStatementState::EmitEncoded<char32_t>(
-    const char32_t *, std::size_t);
-
 } // namespace Fortran::runtime::io

flang/runtime/namelist.cpp

 //===-- runtime/namelist.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 "namelist.h"
 #include "descriptor-io.h"
+#include "emit-encoded.h"
 #include "io-stmt.h"
 #include "flang/Runtime/io-api.h"
 #include <algorithm>
 #include <cstring>
 #include <limits>
 
 namespace Fortran::runtime::io {
 
bool IONAME(OutputNamelist)(Cookie cookie, const NamelistGroup &group) {
   IoStatementState &io{*cookie};
   io.CheckFormattedStmtType<Direction::Output>("OutputNamelist");
   io.mutableModes().inNamelist = true;
   char comma{static_cast<char>(GetComma(io))};
   ConnectionState &connection{io.GetConnectionState()};
   // Internal functions to advance records and convert case
   const auto EmitWithAdvance{[&](char ch) -> bool {
     return (!connection.NeedAdvance(1) || io.AdvanceRecord()) &&
-        io.Emit(&ch, 1);
+        EmitAscii(io, &ch, 1);
   }};
   const auto EmitUpperCase{[&](const char *str) -> bool {
     if (connection.NeedAdvance(std::strlen(str)) &&
-        !(io.AdvanceRecord() && io.Emit(" ", 1))) {
+        !(io.AdvanceRecord() && EmitAscii(io, " ", 1))) {
       return false;
     }
     for (; *str; ++str) {
       char up{*str >= 'a' && *str <= 'z' ? static_cast<char>(*str - 'a' + 'A')
                                          : *str};
-      if (!io.Emit(&up, 1)) {
+      if (!EmitAscii(io, &up, 1)) {
         return false;
       }
     }
     return true;
   }};
   // &GROUP
   if (!(EmitWithAdvance('&') && EmitUpperCase(group.groupName))) {
     return false;
if (negate) {
     }
   }
   return value;
 }
 
 static bool HandleSubscripts(IoStatementState &io, Descriptor &desc,
     const Descriptor &source, const char *name) {
   IoErrorHandler &handler{io.GetIoErrorHandler()};
-  io.HandleRelativePosition(1); // skip '('
   // Allow for blanks in subscripts; they're nonstandard, but not
   // ambiguous within the parentheses.
   SubscriptValue lower[maxRank], upper[maxRank], stride[maxRank];
   int j{0};
   std::size_t contiguousStride{source.ElementBytes()};
   bool ok{true};
   std::size_t byteCount{0};
   std::optional<char32_t> ch{io.GetNextNonBlank(byteCount)};
static bool HandleSubstring(
   if (!pair || pair->first != TypeCategory::Character) {
     handler.SignalError("Substring reference to non-character item '%s'", name);
     return false;
   }
   int kind{pair->second};
   SubscriptValue chars{static_cast<SubscriptValue>(desc.ElementBytes()) / kind};
   // Allow for blanks in substring bounds; they're nonstandard, but not
   // ambiguous within the parentheses.
-  io.HandleRelativePosition(1); // skip '('
   std::optional<SubscriptValue> lower, upper;
   std::size_t byteCount{0};
   std::optional<char32_t> ch{io.GetNextNonBlank(byteCount)};
   if (ch) {
     if (*ch == ':') {
       lower = 1;
     } else {
       lower = GetSubscriptValue(io);
handler.SignalError(
         "Bad substring (missing ')') for NAMELIST input group item '%s'", name);
   }
   return false;
 }
 
 static bool HandleComponent(IoStatementState &io, Descriptor &desc,
     const Descriptor &source, const char *name) {
   IoErrorHandler &handler{io.GetIoErrorHandler()};
-  io.HandleRelativePosition(1); // skip '%'
   char compName[nameBufferSize];
   if (GetLowerCaseName(io, compName, sizeof compName)) {
     const DescriptorAddendum *addendum{source.Addendum()};
     if (const typeInfo::DerivedType *
         type{addendum ? addendum->derivedType() : nullptr}) {
       if (const typeInfo::Component *
           comp{type->FindDataComponent(compName, std::strlen(compName))}) {
         comp->CreatePointerDescriptor(desc, source, handler);
while (true) {
     int whichStaticDesc{0};
     next = io.GetCurrentChar(byteCount);
     bool hadSubscripts{false};
     bool hadSubstring{false};
     if (next && (*next == '(' || *next == '%')) {
       do {
         Descriptor &mutableDescriptor{staticDesc[whichStaticDesc].descriptor()};
         whichStaticDesc ^= 1;
+        io.HandleRelativePosition(byteCount); // skip over '(' or '%'
         if (*next == '(') {
           if (!hadSubstring && (hadSubscripts || useDescriptor->rank() == 0)) {
             mutableDescriptor = *useDescriptor;
             mutableDescriptor.raw().attribute = CFI_attribute_pointer;
             if (!HandleSubstring(io, mutableDescriptor, name)) {
               return false;
             }
             hadSubstring = true;
           } else if (hadSubscripts) {
             handler.SignalError("Multiple sets of subscripts for item '%s' in "
                                 "NAMELIST group '%s'",
                 name, group.groupName);
             return false;
-          } else if (!HandleSubscripts(
-                         io, mutableDescriptor, *useDescriptor, name)) {
+          } else {
+            if (!HandleSubscripts(
               return false;
             }
+          }
           hadSubscripts = true;
         } else {
           if (!HandleComponent(io, mutableDescriptor, *useDescriptor, name)) {
             return false;
           }
           hadSubscripts = false;
           hadSubstring = false;
         }
if (next && *next == comma) {
       io.HandleRelativePosition(byteCount);
     }
   }
   if (!next || *next != '/') {
     handler.SignalError(
         "No '/' found after NAMELIST group '%s'", group.groupName);
     return false;
   }
-  io.HandleRelativePosition(1);
+  io.HandleRelativePosition(byteCount);
   return true;
 }
 
 bool IsNamelistName(IoStatementState &io) {
   if (io.get_if<ListDirectedStatementState<Direction::Input>>()) {
     if (io.mutableModes().inNamelist) {
       SavedPosition savedPosition{io};
       std::size_t byteCount{0};

flang/test/Semantics/io03.f90

! RUN: %python %S/test_errors.py %s %flang_fc1
   read(10, asynchronous='yes') jj
   read(10, eor=9, advance='no', fmt='(I4)') jj
   read(10, eor=9, advance='no', fmt='(I4)') jj
   read(10, asynchronous='yes', id=id) jj
   read(10, '(I4)', advance='no', asynchronous='yes', blank='null', &
       decimal='comma', end=9, eor=9, err=9, id=id, iomsg=msg, iostat=stat2, &
       pad='no', round='processor_defined', size=kk) jj
 
-  !ERROR: Invalid character kind for an internal file variable
   read(internal_file2, *) jj
-
-  !ERROR: Invalid character kind for an internal file variable
   read(internal_file4, *) jj
 
   !ERROR: Internal file must not have a vector subscript
   read(internal_fileA(vv), *) jj
 
   !ERROR: Input variable 'const_int' must be definable
   read(11, *) const_int
 

flang/unittests/Runtime/Format.cpp

 //===-- flang/unittests/Runtime/Format.cpp ----------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "CrashHandlerFixture.h"
+#include "../runtime/connection.h"
 #include "../runtime/format-implementation.h"
 #include "../runtime/io-error.h"
 #include <string>
 #include <tuple>
 #include <vector>
 
 using namespace Fortran::runtime;
 using namespace Fortran::runtime::io;
 using namespace std::literals::string_literals;
 
 using ResultsTy = std::vector<std::string>;
 
 // A test harness context for testing FormatControl
 class TestFormatContext : public IoErrorHandler {
 public:
   using CharType = char;
   TestFormatContext() : IoErrorHandler{"format.cpp", 1} {}
-  bool Emit(const char *, std::size_t);
-  bool Emit(const char16_t *, std::size_t);
-  bool Emit(const char32_t *, std::size_t);
+  bool Emit(const char *, std::size_t, std::size_t = 0);
   bool AdvanceRecord(int = 1);
   void HandleRelativePosition(std::int64_t);
   void HandleAbsolutePosition(std::int64_t);
   void Report(const DataEdit &);
   ResultsTy results;
   MutableModes &mutableModes() { return mutableModes_; }
+  ConnectionState &GetConnectionState() { return connectionState_; }
 
 private:
   MutableModes mutableModes_;
+  ConnectionState connectionState_;
 };
 
-bool TestFormatContext::Emit(const char *s, std::size_t len) {
+bool TestFormatContext::Emit(const char *s, std::size_t len, std::size_t) {
   std::string str{s, len};
   results.push_back("'"s + str + '\'');
   return true;
 }
-bool TestFormatContext::Emit(const char16_t *, std::size_t) {
-  Crash("TestFormatContext::Emit(const char16_t *) called");
-  return false;
-}
-bool TestFormatContext::Emit(const char32_t *, std::size_t) {
-  Crash("TestFormatContext::Emit(const char32_t *) called");
-  return false;
-}
 
 bool TestFormatContext::AdvanceRecord(int n) {
   while (n-- > 0) {
     results.emplace_back("/");
   }
   return true;
 }