caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
05727d94de75e2e98e6ae37c36aeb4f6ca6b2aed
clang-p2996/flang/runtime/edit-output.cpp
Peter Klausler bad5205595 [flang][runtime] Support internal I/O to CHARACTER(KIND/=1) 
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.

Differential Revision: https://reviews.llvm.org/D131107
2022-08-09 08:46:21 -07:00

752 lines
27 KiB
C++
Raw Blame History

//===-- 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.
// When used with character data, endianness is exposed.
template <int LOG2_BASE>
static bool EditBOZOutput(IoStatementState &io, const DataEdit &edit,
const unsigned char *data0, std::size_t bytes) {
int digits{static_cast<int>((bytes * 8) / LOG2_BASE)};
int get{static_cast<int>(bytes * 8) - digits * LOG2_BASE};
if (get > 0) {
++digits;
} else {
get = LOG2_BASE;
}
int shift{7};
int increment{isHostLittleEndian ? -1 : 1};
const unsigned char *data{data0 + (isHostLittleEndian ? bytes - 1 : 0)};
int skippedZeroes{0};
int digit{0};
// The same algorithm is used to generate digits for real (below)
// as well as for generating them only to skip leading zeroes (here).
// Bits are copied one at a time from the source data.
// TODO: Multiple bit copies for hexadecimal, where misalignment
// is not possible; or for octal when all 3 bits come from the
// same byte.
while (bytes > 0) {
if (get == 0) {
if (digit != 0) {
break; // first nonzero leading digit
}
++skippedZeroes;
get = LOG2_BASE;
} else if (shift < 0) {
data += increment;
--bytes;
shift = 7;
} else {
digit = 2 * digit + ((*data >> shift--) & 1);
--get;
}
}
// Emit leading spaces and zeroes; detect field overflow
int leadingZeroes{0};
int editWidth{edit.width.value_or(0)};
int significant{digits - skippedZeroes};
if (edit.digits && significant <= *edit.digits) { // Bw.m, Ow.m, Zw.m
if (*edit.digits == 0 && bytes == 0) {
editWidth = std::max(1, editWidth);
} else {
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 EmitRepeated(io, '*', editWidth);
}
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 (!EmitAscii(io, &ch, 1)) {
return false;
}
get = LOG2_BASE;
digit = 0;
} else if (shift < 0) {
data += increment;
--bytes;
shift = 7;
} else {
digit = 2 * digit + ((*data >> shift--) & 1);
--get;
}
}
return true;
}
template <int KIND>
bool EditIntegerOutput(IoStatementState &io, const DataEdit &edit,
common::HostSignedIntType<8 * KIND> n) {
char buffer[130], *end{&buffer[sizeof buffer]}, *p{end};
bool isNegative{n < 0};
using Unsigned = common::HostUnsignedIntType<8 * KIND>;
Unsigned un{static_cast<Unsigned>(n)};
int signChars{0};
switch (edit.descriptor) {
case DataEdit::ListDirected:
case 'G':
case 'I':
if (isNegative) {
un = -un;
}
if (isNegative || (edit.modes.editingFlags & signPlus)) {
signChars = 1; // '-' or '+'
}
while (un > 0) {
auto quotient{un / 10u};
*--p = '0' + static_cast<int>(un - Unsigned{10} * quotient);
un = quotient;
}
break;
case 'B':
return EditBOZOutput<1>(
io, edit, reinterpret_cast<const unsigned char *>(&n), KIND);
case 'O':
return EditBOZOutput<3>(
io, edit, reinterpret_cast<const unsigned char *>(&n), KIND);
case 'Z':
return EditBOZOutput<4>(
io, edit, reinterpret_cast<const unsigned char *>(&n), KIND);
case 'A': // legacy extension
return EditCharacterOutput(
io, edit, reinterpret_cast<char *>(&n), sizeof n);
default:
io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
"Data edit descriptor '%c' may not be used with an INTEGER data item",
edit.descriptor);
return false;
}
int digits = end - p;
int leadingZeroes{0};
int editWidth{edit.width.value_or(0)};
if (edit.digits && digits <= *edit.digits) { // Iw.m
if (*edit.digits == 0 && n == 0) {
// Iw.0 with zero value: output field must be blank. For I0.0
// and a zero value, emit one blank character.
signChars = 0; // in case of SP
editWidth = std::max(1, editWidth);
} else {
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 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 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;) {
unsigned quotient{e / 10u};
*--exponent = '0' + e - 10 * quotient;
e = quotient;
}
bool overflow{false};
if (edit.expoDigits) {
if (int ed{*edit.expoDigits}) { // Ew.dEe with e > 0
overflow = exponent + ed < eEnd;
while (exponent > exponent_ + 2 /*E+*/ && exponent + ed > eEnd) {
*--exponent = '0';
}
} else if (exponent == eEnd) {
*--exponent = '0'; // Ew.dE0 with zero-valued exponent
}
} else { // ensure at least two exponent digits
while (exponent + 2 > eEnd) {
*--exponent = '0';
}
}
*--exponent = expo < 0 ? '-' : '+';
if (edit.expoDigits || edit.IsListDirected() || exponent + 3 == eEnd) {
*--exponent = edit.descriptor == 'D' ? 'D' : 'E'; // not 'G' or 'Q'
}
length = eEnd - exponent;
return overflow ? nullptr : exponent;
}
bool RealOutputEditingBase::EmitPrefix(
const DataEdit &edit, std::size_t length, std::size_t width) {
if (edit.IsListDirected()) {
int prefixLength{edit.descriptor == DataEdit::ListDirectedRealPart ? 2
: edit.descriptor == DataEdit::ListDirectedImaginaryPart ? 0
: 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()) &&
EmitAscii(io_, " (", prefixLength);
} else if (width > length) {
return EmitRepeated(io_, ' ', width - length);
} else {
return true;
}
}
bool RealOutputEditingBase::EmitSuffix(const DataEdit &edit) {
if (edit.descriptor == DataEdit::ListDirectedRealPart) {
return EmitAscii(
io_, edit.modes.editingFlags & decimalComma ? ";" : ",", 1);
} else if (edit.descriptor == DataEdit::ListDirectedImaginaryPart) {
return EmitAscii(io_, ")", 1);
} else {
return true;
}
}
template <int binaryPrecision>
decimal::ConversionToDecimalResult RealOutputEditing<binaryPrecision>::Convert(
int significantDigits, enum decimal::FortranRounding rounding, int flags) {
auto converted{decimal::ConvertToDecimal<binaryPrecision>(buffer_,
sizeof buffer_, static_cast<enum decimal::DecimalConversionFlags>(flags),
significantDigits, rounding, x_)};
if (!converted.str) { // overflow
io_.GetIoErrorHandler().Crash(
"RealOutputEditing::Convert : buffer size %zd was insufficient",
sizeof buffer_);
}
return converted;
}
// 13.7.2.3.3 in F'2018
template <int binaryPrecision>
bool RealOutputEditing<binaryPrecision>::EditEorDOutput(const DataEdit &edit) {
int editDigits{edit.digits.value_or(0)}; // 'd' field
int editWidth{edit.width.value_or(0)}; // 'w' field
int significantDigits{editDigits};
int flags{0};
if (edit.modes.editingFlags & signPlus) {
flags |= decimal::AlwaysSign;
}
bool noLeadingSpaces{editWidth == 0};
int scale{edit.modes.scale}; // 'kP' value
if (editWidth == 0) { // "the processor selects the field width"
if (edit.digits.has_value()) { // E0.d
if (editDigits == 0 && scale <= 0) { // E0.0
significantDigits = 1;
}
} else { // E0
flags |= decimal::Minimize;
significantDigits =
sizeof buffer_ - 5; // sign, NUL, + 3 extra for EN scaling
}
}
bool isEN{edit.variation == 'N'};
bool isES{edit.variation == 'S'};
int zeroesAfterPoint{0};
if (isEN) {
scale = IsZero() ? 1 : 3;
significantDigits += scale;
} else if (isES) {
scale = 1;
++significantDigits;
} else if (scale < 0) {
if (scale <= -editDigits) {
io_.GetIoErrorHandler().SignalError(IostatBadScaleFactor,
"Scale factor (kP) %d cannot be less than -d (%d)", scale,
-editDigits);
return false;
}
zeroesAfterPoint = -scale;
significantDigits = std::max(0, significantDigits - zeroesAfterPoint);
} else if (scale > 0) {
if (scale >= editDigits + 2) {
io_.GetIoErrorHandler().SignalError(IostatBadScaleFactor,
"Scale factor (kP) %d cannot be greater than d+2 (%d)", scale,
editDigits + 2);
return false;
}
++significantDigits;
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) &&
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) {
if (significantDigits > 1) {
--significantDigits;
--scale;
continue;
}
// Rounded nines up to a 1.
scale += modulus;
converted.decimalExponent -= modulus;
}
if (scale > 3) {
int adjust{3 * (scale / 3)};
scale -= adjust;
converted.decimalExponent += adjust;
} else if (scale < 1) {
int adjust{3 - 3 * (scale / 3)};
scale += adjust;
converted.decimalExponent -= adjust;
}
significantDigits = editDigits + scale;
}
// Format the exponent (see table 13.1 for all the cases)
int expoLength{0};
const char *exponent{
FormatExponent(converted.decimalExponent, edit, expoLength)};
int signLength{*converted.str == '-' || *converted.str == '+' ? 1 : 0};
int convertedDigits{static_cast<int>(converted.length) - signLength};
int zeroesBeforePoint{std::max(0, scale - convertedDigits)};
int digitsBeforePoint{std::max(0, scale - zeroesBeforePoint)};
int digitsAfterPoint{convertedDigits - digitsBeforePoint};
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 EmitRepeated(io_, '*', width);
}
if (totalLength < width && digitsBeforePoint == 0 &&
zeroesBeforePoint == 0) {
zeroesBeforePoint = 1;
++totalLength;
}
if (totalLength < width && noLeadingSpaces) {
width = totalLength;
}
return EmitPrefix(edit, totalLength, width) &&
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
enum decimal::FortranRounding rounding{edit.modes.round};
int flags{0};
if (edit.modes.editingFlags & signPlus) {
flags |= decimal::AlwaysSign;
}
if (editWidth == 0) { // "the processor selects the field width"
if (!edit.digits.has_value()) { // F0
flags |= decimal::Minimize;
fracDigits = sizeof buffer_ - 2; // sign & NUL
}
}
// Multiple conversions may be needed to get the right number of
// 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) &&
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;
}
int trailingOnes{0};
if (expo > extraDigits && extraDigits >= 0 && canIncrease) {
extraDigits = expo;
if (!edit.digits.has_value()) { // F0
fracDigits = sizeof buffer_ - extraDigits - 2; // sign & NUL
}
canIncrease = false; // only once
continue;
} else if (expo == -fracDigits && convertedDigits > 0) {
if ((rounding == decimal::FortranRounding::RoundUp &&
*converted.str != '-') ||
(rounding == decimal::FortranRounding::RoundDown &&
*converted.str == '-') ||
(rounding == decimal::FortranRounding::RoundToZero &&
rounding != edit.modes.round && // it changed below
converted.str[signLength] >= '5')) {
// Round up/down to a scaled 1
++expo;
convertedDigits = 0;
trailingOnes = 1;
} else if (rounding != decimal::FortranRounding::RoundToZero) {
// Convert again with truncation so first digit can be checked
// on the next iteration by the code above
rounding = decimal::FortranRounding::RoundToZero;
continue;
} else {
// Value rounds down to zero
expo = 0;
convertedDigits = 0;
}
} else if (expo < extraDigits && extraDigits > -fracDigits) {
extraDigits = std::max(expo, -fracDigits);
continue;
}
int digitsBeforePoint{std::max(0, std::min(expo, convertedDigits))};
int zeroesBeforePoint{std::max(0, expo - digitsBeforePoint)};
int zeroesAfterPoint{std::min(fracDigits, std::max(0, -expo))};
int digitsAfterPoint{convertedDigits - digitsBeforePoint};
int trailingZeroes{flags & decimal::Minimize
? 0
: std::max(0,
fracDigits -
(zeroesAfterPoint + digitsAfterPoint + trailingOnes))};
if (digitsBeforePoint + zeroesBeforePoint + zeroesAfterPoint +
digitsAfterPoint + trailingOnes + trailingZeroes ==
0) {
zeroesBeforePoint = 1; // "." -> "0."
}
int totalLength{signLength + digitsBeforePoint + zeroesBeforePoint +
1 /*'.'*/ + zeroesAfterPoint + digitsAfterPoint + trailingOnes +
trailingZeroes};
int width{editWidth > 0 ? editWidth : totalLength};
if (totalLength > width) {
return EmitRepeated(io_, '*', width);
}
if (totalLength < width && digitsBeforePoint + zeroesBeforePoint == 0) {
zeroesBeforePoint = 1;
++totalLength;
}
return EmitPrefix(edit, totalLength, width) &&
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)};
int significantDigits{
edit.digits.value_or(BinaryFloatingPoint::decimalPrecision)}; // 'd'
if (editWidth > 0 && significantDigits == 0) {
return edit; // Gw.0Ee -> Ew.0Ee for w > 0
}
int flags{0};
if (edit.modes.editingFlags & signPlus) {
flags |= decimal::AlwaysSign;
}
decimal::ConversionToDecimalResult converted{
Convert(significantDigits, edit.modes.round, flags)};
if (IsInfOrNaN(converted)) {
return edit; // Inf/Nan -> Ew.d (same as Fw.d)
}
int expo{IsZero() ? 1 : converted.decimalExponent}; // 's'
if (expo < 0 || expo > significantDigits) {
if (editWidth == 0 && !edit.expoDigits) { // G0.d -> G0.dE0
edit.expoDigits = 0;
}
return edit; // Ew.dEe
}
edit.descriptor = 'F';
edit.modes.scale = 0; // kP is ignored for G when no exponent field
trailingBlanks_ = 0;
if (editWidth > 0) {
int expoDigits{edit.expoDigits.value_or(0)};
trailingBlanks_ = expoDigits > 0 ? expoDigits + 2 : 4; // 'n'
*edit.width = std::max(0, editWidth - trailingBlanks_);
}
if (edit.digits.has_value()) {
*edit.digits = std::max(0, *edit.digits - expo);
}
return edit;
}
// 13.10.4 in F'2018
template <int binaryPrecision>
bool RealOutputEditing<binaryPrecision>::EditListDirectedOutput(
const DataEdit &edit) {
decimal::ConversionToDecimalResult converted{Convert(1, edit.modes.round)};
if (IsInfOrNaN(converted)) {
return EditEorDOutput(edit);
}
int expo{converted.decimalExponent};
// The decimal precision of 16-bit floating-point types is very low,
// so use a reasonable cap of 6 to allow more values to be emitted
// with Fw.d editing.
static constexpr int maxExpo{
std::max(6, BinaryFloatingPoint::decimalPrecision)};
if (expo < 0 || expo > maxExpo) {
DataEdit copy{edit};
copy.modes.scale = 1; // 1P
return EditEorDOutput(copy);
}
return EditFOutput(edit);
}
// 13.7.5.2.6 in F'2018
template <int binaryPrecision>
bool RealOutputEditing<binaryPrecision>::EditEXOutput(const DataEdit &) {
io_.GetIoErrorHandler().Crash(
"not yet implemented: EX output editing"); // TODO
}
template <int KIND> bool RealOutputEditing<KIND>::Edit(const DataEdit &edit) {
switch (edit.descriptor) {
case 'D':
return EditEorDOutput(edit);
case 'E':
if (edit.variation == 'X') {
return EditEXOutput(edit);
} else {
return EditEorDOutput(edit);
}
case 'F':
return EditFOutput(edit);
case 'B':
return EditBOZOutput<1>(io_, edit,
reinterpret_cast<const unsigned char *>(&x_),
common::BitsForBinaryPrecision(common::PrecisionOfRealKind(KIND)) >> 3);
case 'O':
return EditBOZOutput<3>(io_, edit,
reinterpret_cast<const unsigned char *>(&x_),
common::BitsForBinaryPrecision(common::PrecisionOfRealKind(KIND)) >> 3);
case 'Z':
return EditBOZOutput<4>(io_, edit,
reinterpret_cast<const unsigned char *>(&x_),
common::BitsForBinaryPrecision(common::PrecisionOfRealKind(KIND)) >> 3);
case 'G':
return Edit(EditForGOutput(edit));
case 'A': // legacy extension
return EditCharacterOutput(
io_, edit, reinterpret_cast<char *>(&x_), sizeof x_);
default:
if (edit.IsListDirected()) {
return EditListDirectedOutput(edit);
}
io_.GetIoErrorHandler().SignalError(IostatErrorInFormat,
"Data edit descriptor '%c' may not be used with a REAL data item",
edit.descriptor);
return false;
}
return false;
}
bool ListDirectedLogicalOutput(IoStatementState &io,
ListDirectedStatementState<Direction::Output> &list, bool truth) {
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 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,
reinterpret_cast<const unsigned char *>(&truth), sizeof truth);
default:
io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
"Data edit descriptor '%c' may not be used with a LOGICAL data item",
edit.descriptor);
return false;
}
}
template <typename CHAR>
bool ListDirectedCharacterOutput(IoStatementState &io,
ListDirectedStatementState<Direction::Output> &list, const CHAR *x,
std::size_t length) {
bool ok{true};
MutableModes &modes{io.mutableModes()};
ConnectionState &connection{io.GetConnectionState()};
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 && 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 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, oneAtATime),
connection.RemainingSpaceInRecord())}) {
ok = EmitEncoded(io, x + put, chunk);
put += chunk;
} else {
ok = io.AdvanceRecord() && EmitAscii(io, " ", 1);
}
}
list.set_lastWasUndelimitedCharacter(true);
}
return ok;
}
template <typename CHAR>
bool EditCharacterOutput(IoStatementState &io, const DataEdit &edit,
const CHAR *x, std::size_t length) {
int len{static_cast<int>(length)};
int width{edit.width.value_or(len)};
switch (edit.descriptor) {
case 'A':
break;
case 'G':
if (width == 0) {
width = len;
}
break;
case 'B':
return EditBOZOutput<1>(io, edit,
reinterpret_cast<const unsigned char *>(x), sizeof(CHAR) * length);
case 'O':
return EditBOZOutput<3>(io, edit,
reinterpret_cast<const unsigned char *>(x), sizeof(CHAR) * length);
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 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);
template bool EditIntegerOutput<8>(
IoStatementState &, const DataEdit &, std::int64_t);
template bool EditIntegerOutput<16>(
IoStatementState &, const DataEdit &, common::int128_t);
template class RealOutputEditing<2>;
template class RealOutputEditing<3>;
template class RealOutputEditing<4>;
template class RealOutputEditing<8>;
template class RealOutputEditing<10>;
// TODO: double/double
template class RealOutputEditing<16>;
template bool ListDirectedCharacterOutput(IoStatementState &,
ListDirectedStatementState<Direction::Output> &, const char *,
std::size_t chars);
template bool ListDirectedCharacterOutput(IoStatementState &,
ListDirectedStatementState<Direction::Output> &, const char16_t *,
std::size_t chars);
template bool ListDirectedCharacterOutput(IoStatementState &,
ListDirectedStatementState<Direction::Output> &, const char32_t *,
std::size_t chars);
template bool EditCharacterOutput(
IoStatementState &, const DataEdit &, const char *, std::size_t chars);
template bool EditCharacterOutput(
IoStatementState &, const DataEdit &, const char16_t *, std::size_t chars);
template bool EditCharacterOutput(
IoStatementState &, const DataEdit &, const char32_t *, std::size_t chars);
} // namespace Fortran::runtime::io
Reference in New Issue View Git Blame Copy Permalink