Diana Picus | 651f58b | 2021-09-02 08:14:01 +0000 | [diff] [blame] | 1 | //===-- runtime/edit-output.cpp -------------------------------------------===// |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 2 | // |
| 3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 | // See https://llvm.org/LICENSE.txt for license information. |
| 5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 | // |
| 7 | //===----------------------------------------------------------------------===// |
| 8 | |
| 9 | #include "edit-output.h" |
| 10 | #include "flang/Common/uint128.h" |
Isuru Fernando | 231fae9 | 2020-03-12 12:52:29 -0500 | [diff] [blame] | 11 | #include <algorithm> |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 12 | |
| 13 | namespace Fortran::runtime::io { |
| 14 | |
peter klausler | f65f830 | 2021-10-11 15:41:14 -0700 | [diff] [blame] | 15 | template <int KIND> |
| 16 | bool EditIntegerOutput(IoStatementState &io, const DataEdit &edit, |
| 17 | common::HostSignedIntType<8 * KIND> n) { |
| 18 | char buffer[130], *end{&buffer[sizeof buffer]}, *p{end}; |
| 19 | bool isNegative{n < 0}; |
| 20 | using Unsigned = common::HostUnsignedIntType<8 * KIND>; |
| 21 | Unsigned un{static_cast<Unsigned>(n)}; |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 22 | int signChars{0}; |
| 23 | switch (edit.descriptor) { |
| 24 | case DataEdit::ListDirected: |
| 25 | case 'G': |
| 26 | case 'I': |
peter klausler | f65f830 | 2021-10-11 15:41:14 -0700 | [diff] [blame] | 27 | if (isNegative) { |
peter klausler | c5a5517 | 2021-10-12 18:57:58 -0700 | [diff] [blame] | 28 | un = -un; |
peter klausler | f65f830 | 2021-10-11 15:41:14 -0700 | [diff] [blame] | 29 | } |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 30 | if (isNegative || (edit.modes.editingFlags & signPlus)) { |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 31 | signChars = 1; // '-' or '+' |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 32 | } |
| 33 | while (un > 0) { |
peter klausler | e99d184 | 2020-09-30 12:26:25 -0700 | [diff] [blame] | 34 | auto quotient{un / 10u}; |
peter klausler | c5a5517 | 2021-10-12 18:57:58 -0700 | [diff] [blame] | 35 | *--p = '0' + static_cast<int>(un - Unsigned{10} * quotient); |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 36 | un = quotient; |
| 37 | } |
| 38 | break; |
| 39 | case 'B': |
| 40 | for (; un > 0; un >>= 1) { |
| 41 | *--p = '0' + (static_cast<int>(un) & 1); |
| 42 | } |
| 43 | break; |
| 44 | case 'O': |
| 45 | for (; un > 0; un >>= 3) { |
| 46 | *--p = '0' + (static_cast<int>(un) & 7); |
| 47 | } |
| 48 | break; |
| 49 | case 'Z': |
| 50 | for (; un > 0; un >>= 4) { |
| 51 | int digit = static_cast<int>(un) & 0xf; |
| 52 | *--p = digit >= 10 ? 'A' + (digit - 10) : '0' + digit; |
| 53 | } |
| 54 | break; |
peter klausler | b83242e | 2021-10-21 13:33:07 -0700 | [diff] [blame] | 55 | case 'A': // legacy extension |
| 56 | return EditDefaultCharacterOutput( |
| 57 | io, edit, reinterpret_cast<char *>(&n), sizeof n); |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 58 | default: |
| 59 | io.GetIoErrorHandler().Crash( |
| 60 | "Data edit descriptor '%c' may not be used with an INTEGER data item", |
| 61 | edit.descriptor); |
| 62 | return false; |
| 63 | } |
| 64 | |
| 65 | int digits = end - p; |
| 66 | int leadingZeroes{0}; |
| 67 | int editWidth{edit.width.value_or(0)}; |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 68 | if (edit.digits && digits <= *edit.digits) { // Iw.m |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 69 | if (*edit.digits == 0 && n == 0) { |
| 70 | // Iw.0 with zero value: output field must be blank. For I0.0 |
| 71 | // and a zero value, emit one blank character. |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 72 | signChars = 0; // in case of SP |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 73 | editWidth = std::max(1, editWidth); |
| 74 | } else { |
| 75 | leadingZeroes = *edit.digits - digits; |
| 76 | } |
| 77 | } else if (n == 0) { |
| 78 | leadingZeroes = 1; |
| 79 | } |
peter klausler | 6a1c3ef | 2021-05-05 11:37:49 -0700 | [diff] [blame] | 80 | int subTotal{signChars + leadingZeroes + digits}; |
| 81 | int leadingSpaces{std::max(0, editWidth - subTotal)}; |
| 82 | if (editWidth > 0 && leadingSpaces + subTotal > editWidth) { |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 83 | return io.EmitRepeated('*', editWidth); |
| 84 | } |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 85 | if (edit.IsListDirected()) { |
peter klausler | 6a1c3ef | 2021-05-05 11:37:49 -0700 | [diff] [blame] | 86 | int total{std::max(leadingSpaces, 1) + subTotal}; |
| 87 | if (io.GetConnectionState().NeedAdvance(static_cast<std::size_t>(total)) && |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 88 | !io.AdvanceRecord()) { |
| 89 | return false; |
| 90 | } |
| 91 | leadingSpaces = 1; |
| 92 | } |
| 93 | return io.EmitRepeated(' ', leadingSpaces) && |
| 94 | io.Emit(n < 0 ? "-" : "+", signChars) && |
| 95 | io.EmitRepeated('0', leadingZeroes) && io.Emit(p, digits); |
| 96 | } |
| 97 | |
| 98 | // Formats the exponent (see table 13.1 for all the cases) |
| 99 | const char *RealOutputEditingBase::FormatExponent( |
| 100 | int expo, const DataEdit &edit, int &length) { |
| 101 | char *eEnd{&exponent_[sizeof exponent_]}; |
| 102 | char *exponent{eEnd}; |
| 103 | for (unsigned e{static_cast<unsigned>(std::abs(expo))}; e > 0;) { |
peter klausler | e99d184 | 2020-09-30 12:26:25 -0700 | [diff] [blame] | 104 | unsigned quotient{e / 10u}; |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 105 | *--exponent = '0' + e - 10 * quotient; |
| 106 | e = quotient; |
| 107 | } |
| 108 | if (edit.expoDigits) { |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 109 | if (int ed{*edit.expoDigits}) { // Ew.dEe with e > 0 |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 110 | while (exponent > exponent_ + 2 /*E+*/ && exponent + ed > eEnd) { |
| 111 | *--exponent = '0'; |
| 112 | } |
| 113 | } else if (exponent == eEnd) { |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 114 | *--exponent = '0'; // Ew.dE0 with zero-valued exponent |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 115 | } |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 116 | } else { // ensure at least two exponent digits |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 117 | while (exponent + 2 > eEnd) { |
| 118 | *--exponent = '0'; |
| 119 | } |
| 120 | } |
| 121 | *--exponent = expo < 0 ? '-' : '+'; |
peter klausler | b1afbce | 2020-12-15 10:49:01 -0800 | [diff] [blame] | 122 | if (edit.expoDigits || edit.IsListDirected() || exponent + 3 == eEnd) { |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 123 | *--exponent = edit.descriptor == 'D' ? 'D' : 'E'; // not 'G' |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 124 | } |
| 125 | length = eEnd - exponent; |
| 126 | return exponent; |
| 127 | } |
| 128 | |
| 129 | bool RealOutputEditingBase::EmitPrefix( |
| 130 | const DataEdit &edit, std::size_t length, std::size_t width) { |
| 131 | if (edit.IsListDirected()) { |
Tim Keith | dd90408 | 2020-07-01 16:51:44 -0700 | [diff] [blame] | 132 | int prefixLength{edit.descriptor == DataEdit::ListDirectedRealPart ? 2 |
| 133 | : edit.descriptor == DataEdit::ListDirectedImaginaryPart ? 0 |
| 134 | : 1}; |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 135 | int suffixLength{edit.descriptor == DataEdit::ListDirectedRealPart || |
| 136 | edit.descriptor == DataEdit::ListDirectedImaginaryPart |
| 137 | ? 1 |
| 138 | : 0}; |
| 139 | length += prefixLength + suffixLength; |
| 140 | ConnectionState &connection{io_.GetConnectionState()}; |
peter klausler | 6a1c3ef | 2021-05-05 11:37:49 -0700 | [diff] [blame] | 141 | return (!connection.NeedAdvance(length) || io_.AdvanceRecord()) && |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 142 | io_.Emit(" (", prefixLength); |
| 143 | } else if (width > length) { |
| 144 | return io_.EmitRepeated(' ', width - length); |
| 145 | } else { |
| 146 | return true; |
| 147 | } |
| 148 | } |
| 149 | |
| 150 | bool RealOutputEditingBase::EmitSuffix(const DataEdit &edit) { |
| 151 | if (edit.descriptor == DataEdit::ListDirectedRealPart) { |
| 152 | return io_.Emit(edit.modes.editingFlags & decimalComma ? ";" : ",", 1); |
| 153 | } else if (edit.descriptor == DataEdit::ListDirectedImaginaryPart) { |
| 154 | return io_.Emit(")", 1); |
| 155 | } else { |
| 156 | return true; |
| 157 | } |
| 158 | } |
| 159 | |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 160 | template <int binaryPrecision> |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 161 | decimal::ConversionToDecimalResult RealOutputEditing<binaryPrecision>::Convert( |
Peter Klausler | d1b09ad | 2021-11-10 14:02:30 -0800 | [diff] [blame] | 162 | int significantDigits, enum decimal::FortranRounding rounding, int flags) { |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 163 | auto converted{decimal::ConvertToDecimal<binaryPrecision>(buffer_, |
| 164 | sizeof buffer_, static_cast<enum decimal::DecimalConversionFlags>(flags), |
Peter Klausler | d1b09ad | 2021-11-10 14:02:30 -0800 | [diff] [blame] | 165 | significantDigits, rounding, x_)}; |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 166 | if (!converted.str) { // overflow |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 167 | io_.GetIoErrorHandler().Crash( |
| 168 | "RealOutputEditing::Convert : buffer size %zd was insufficient", |
| 169 | sizeof buffer_); |
| 170 | } |
| 171 | return converted; |
| 172 | } |
| 173 | |
| 174 | // 13.7.2.3.3 in F'2018 |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 175 | template <int binaryPrecision> |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 176 | bool RealOutputEditing<binaryPrecision>::EditEorDOutput(const DataEdit &edit) { |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 177 | int editDigits{edit.digits.value_or(0)}; // 'd' field |
| 178 | int editWidth{edit.width.value_or(0)}; // 'w' field |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 179 | int significantDigits{editDigits}; |
| 180 | int flags{0}; |
Peter Klausler | d1b09ad | 2021-11-10 14:02:30 -0800 | [diff] [blame] | 181 | if (edit.modes.editingFlags & signPlus) { |
| 182 | flags |= decimal::AlwaysSign; |
| 183 | } |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 184 | if (editWidth == 0) { // "the processor selects the field width" |
| 185 | if (edit.digits.has_value()) { // E0.d |
| 186 | editWidth = editDigits + 6; // -.666E+ee |
| 187 | } else { // E0 |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 188 | flags |= decimal::Minimize; |
| 189 | significantDigits = |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 190 | sizeof buffer_ - 5; // sign, NUL, + 3 extra for EN scaling |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 191 | } |
| 192 | } |
| 193 | bool isEN{edit.variation == 'N'}; |
| 194 | bool isES{edit.variation == 'S'}; |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 195 | int scale{isEN || isES ? 1 : edit.modes.scale}; // 'kP' value |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 196 | int zeroesAfterPoint{0}; |
| 197 | if (scale < 0) { |
| 198 | zeroesAfterPoint = -scale; |
| 199 | significantDigits = std::max(0, significantDigits - zeroesAfterPoint); |
| 200 | } else if (scale > 0) { |
| 201 | ++significantDigits; |
| 202 | scale = std::min(scale, significantDigits + 1); |
| 203 | } |
| 204 | // In EN editing, multiple attempts may be necessary, so it's in a loop. |
| 205 | while (true) { |
| 206 | decimal::ConversionToDecimalResult converted{ |
Peter Klausler | d1b09ad | 2021-11-10 14:02:30 -0800 | [diff] [blame] | 207 | Convert(significantDigits, edit.modes.round, flags)}; |
peter klausler | 0df6f8f | 2020-06-19 13:32:26 -0700 | [diff] [blame] | 208 | if (IsInfOrNaN(converted)) { |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 209 | return EmitPrefix(edit, converted.length, editWidth) && |
| 210 | io_.Emit(converted.str, converted.length) && EmitSuffix(edit); |
| 211 | } |
| 212 | if (!IsZero()) { |
| 213 | converted.decimalExponent -= scale; |
| 214 | } |
| 215 | if (isEN && scale < 3 && (converted.decimalExponent % 3) != 0) { |
| 216 | // EN mode: boost the scale and significant digits, try again; need |
| 217 | // an effective exponent field that's a multiple of three. |
| 218 | ++scale; |
| 219 | ++significantDigits; |
| 220 | continue; |
| 221 | } |
| 222 | // Format the exponent (see table 13.1 for all the cases) |
| 223 | int expoLength{0}; |
| 224 | const char *exponent{ |
| 225 | FormatExponent(converted.decimalExponent, edit, expoLength)}; |
| 226 | int signLength{*converted.str == '-' || *converted.str == '+' ? 1 : 0}; |
| 227 | int convertedDigits{static_cast<int>(converted.length) - signLength}; |
| 228 | int zeroesBeforePoint{std::max(0, scale - convertedDigits)}; |
| 229 | int digitsBeforePoint{std::max(0, scale - zeroesBeforePoint)}; |
| 230 | int digitsAfterPoint{convertedDigits - digitsBeforePoint}; |
| 231 | int trailingZeroes{flags & decimal::Minimize |
| 232 | ? 0 |
| 233 | : std::max(0, |
| 234 | significantDigits - (convertedDigits + zeroesBeforePoint))}; |
| 235 | int totalLength{signLength + digitsBeforePoint + zeroesBeforePoint + |
| 236 | 1 /*'.'*/ + zeroesAfterPoint + digitsAfterPoint + trailingZeroes + |
| 237 | expoLength}; |
| 238 | int width{editWidth > 0 ? editWidth : totalLength}; |
| 239 | if (totalLength > width) { |
| 240 | return io_.EmitRepeated('*', width); |
| 241 | } |
| 242 | if (totalLength < width && digitsBeforePoint == 0 && |
| 243 | zeroesBeforePoint == 0) { |
| 244 | zeroesBeforePoint = 1; |
| 245 | ++totalLength; |
| 246 | } |
| 247 | return EmitPrefix(edit, totalLength, width) && |
| 248 | io_.Emit(converted.str, signLength + digitsBeforePoint) && |
| 249 | io_.EmitRepeated('0', zeroesBeforePoint) && |
| 250 | io_.Emit(edit.modes.editingFlags & decimalComma ? "," : ".", 1) && |
| 251 | io_.EmitRepeated('0', zeroesAfterPoint) && |
| 252 | io_.Emit( |
| 253 | converted.str + signLength + digitsBeforePoint, digitsAfterPoint) && |
| 254 | io_.EmitRepeated('0', trailingZeroes) && |
| 255 | io_.Emit(exponent, expoLength) && EmitSuffix(edit); |
| 256 | } |
| 257 | } |
| 258 | |
| 259 | // 13.7.2.3.2 in F'2018 |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 260 | template <int binaryPrecision> |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 261 | bool RealOutputEditing<binaryPrecision>::EditFOutput(const DataEdit &edit) { |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 262 | int fracDigits{edit.digits.value_or(0)}; // 'd' field |
peter klausler | 0df6f8f | 2020-06-19 13:32:26 -0700 | [diff] [blame] | 263 | const int editWidth{edit.width.value_or(0)}; // 'w' field |
Peter Klausler | d1b09ad | 2021-11-10 14:02:30 -0800 | [diff] [blame] | 264 | enum decimal::FortranRounding rounding{edit.modes.round}; |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 265 | int flags{0}; |
Peter Klausler | d1b09ad | 2021-11-10 14:02:30 -0800 | [diff] [blame] | 266 | if (edit.modes.editingFlags & signPlus) { |
| 267 | flags |= decimal::AlwaysSign; |
| 268 | } |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 269 | if (editWidth == 0) { // "the processor selects the field width" |
| 270 | if (!edit.digits.has_value()) { // F0 |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 271 | flags |= decimal::Minimize; |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 272 | fracDigits = sizeof buffer_ - 2; // sign & NUL |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 273 | } |
| 274 | } |
| 275 | // Multiple conversions may be needed to get the right number of |
| 276 | // effective rounded fractional digits. |
peter klausler | 0df6f8f | 2020-06-19 13:32:26 -0700 | [diff] [blame] | 277 | int extraDigits{0}; |
peter klausler | 4876520 | 2021-08-02 14:37:40 -0700 | [diff] [blame] | 278 | bool canIncrease{true}; |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 279 | while (true) { |
| 280 | decimal::ConversionToDecimalResult converted{ |
Peter Klausler | d1b09ad | 2021-11-10 14:02:30 -0800 | [diff] [blame] | 281 | Convert(extraDigits + fracDigits, rounding, flags)}; |
peter klausler | 0df6f8f | 2020-06-19 13:32:26 -0700 | [diff] [blame] | 282 | if (IsInfOrNaN(converted)) { |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 283 | return EmitPrefix(edit, converted.length, editWidth) && |
| 284 | io_.Emit(converted.str, converted.length) && EmitSuffix(edit); |
| 285 | } |
peter klausler | 567462b | 2020-09-30 13:04:44 -0700 | [diff] [blame] | 286 | int scale{IsZero() ? 1 : edit.modes.scale}; // kP |
| 287 | int expo{converted.decimalExponent + scale}; |
Peter Klausler | d1b09ad | 2021-11-10 14:02:30 -0800 | [diff] [blame] | 288 | int signLength{*converted.str == '-' || *converted.str == '+' ? 1 : 0}; |
| 289 | int convertedDigits{static_cast<int>(converted.length) - signLength}; |
| 290 | int trailingOnes{0}; |
peter klausler | 4876520 | 2021-08-02 14:37:40 -0700 | [diff] [blame] | 291 | if (expo > extraDigits && extraDigits >= 0 && canIncrease) { |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 292 | extraDigits = expo; |
peter klausler | 0df6f8f | 2020-06-19 13:32:26 -0700 | [diff] [blame] | 293 | if (!edit.digits.has_value()) { // F0 |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 294 | fracDigits = sizeof buffer_ - extraDigits - 2; // sign & NUL |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 295 | } |
peter klausler | 4876520 | 2021-08-02 14:37:40 -0700 | [diff] [blame] | 296 | canIncrease = false; // only once |
peter klausler | 0df6f8f | 2020-06-19 13:32:26 -0700 | [diff] [blame] | 297 | continue; |
Peter Klausler | d1b09ad | 2021-11-10 14:02:30 -0800 | [diff] [blame] | 298 | } else if (expo == -fracDigits && convertedDigits > 0) { |
| 299 | if (rounding != decimal::FortranRounding::RoundToZero) { |
| 300 | // Convert again without rounding so that we can round here |
| 301 | rounding = decimal::FortranRounding::RoundToZero; |
| 302 | continue; |
| 303 | } else if (converted.str[signLength] >= '5') { |
| 304 | // Value rounds up to a scaled 1 (e.g., 0.06 for F5.1 -> 0.1) |
| 305 | ++expo; |
| 306 | convertedDigits = 0; |
| 307 | trailingOnes = 1; |
| 308 | } else { |
| 309 | // Value rounds down to zero |
| 310 | expo = 0; |
| 311 | convertedDigits = 0; |
| 312 | } |
peter klausler | 0df6f8f | 2020-06-19 13:32:26 -0700 | [diff] [blame] | 313 | } else if (expo < extraDigits && extraDigits > -fracDigits) { |
| 314 | extraDigits = std::max(expo, -fracDigits); |
| 315 | continue; |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 316 | } |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 317 | int digitsBeforePoint{std::max(0, std::min(expo, convertedDigits))}; |
| 318 | int zeroesBeforePoint{std::max(0, expo - digitsBeforePoint)}; |
peter klausler | 0df6f8f | 2020-06-19 13:32:26 -0700 | [diff] [blame] | 319 | int zeroesAfterPoint{std::min(fracDigits, std::max(0, -expo))}; |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 320 | int digitsAfterPoint{convertedDigits - digitsBeforePoint}; |
| 321 | int trailingZeroes{flags & decimal::Minimize |
| 322 | ? 0 |
Peter Klausler | d1b09ad | 2021-11-10 14:02:30 -0800 | [diff] [blame] | 323 | : std::max(0, |
| 324 | fracDigits - |
| 325 | (zeroesAfterPoint + digitsAfterPoint + trailingOnes))}; |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 326 | if (digitsBeforePoint + zeroesBeforePoint + zeroesAfterPoint + |
Peter Klausler | d1b09ad | 2021-11-10 14:02:30 -0800 | [diff] [blame] | 327 | digitsAfterPoint + trailingOnes + trailingZeroes == |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 328 | 0) { |
peter klausler | 0df6f8f | 2020-06-19 13:32:26 -0700 | [diff] [blame] | 329 | zeroesBeforePoint = 1; // "." -> "0." |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 330 | } |
| 331 | int totalLength{signLength + digitsBeforePoint + zeroesBeforePoint + |
Peter Klausler | d1b09ad | 2021-11-10 14:02:30 -0800 | [diff] [blame] | 332 | 1 /*'.'*/ + zeroesAfterPoint + digitsAfterPoint + trailingOnes + |
| 333 | trailingZeroes}; |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 334 | int width{editWidth > 0 ? editWidth : totalLength}; |
| 335 | if (totalLength > width) { |
| 336 | return io_.EmitRepeated('*', width); |
| 337 | } |
| 338 | if (totalLength < width && digitsBeforePoint + zeroesBeforePoint == 0) { |
| 339 | zeroesBeforePoint = 1; |
| 340 | ++totalLength; |
| 341 | } |
| 342 | return EmitPrefix(edit, totalLength, width) && |
| 343 | io_.Emit(converted.str, signLength + digitsBeforePoint) && |
| 344 | io_.EmitRepeated('0', zeroesBeforePoint) && |
| 345 | io_.Emit(edit.modes.editingFlags & decimalComma ? "," : ".", 1) && |
| 346 | io_.EmitRepeated('0', zeroesAfterPoint) && |
| 347 | io_.Emit( |
| 348 | converted.str + signLength + digitsBeforePoint, digitsAfterPoint) && |
Peter Klausler | d1b09ad | 2021-11-10 14:02:30 -0800 | [diff] [blame] | 349 | io_.EmitRepeated('1', trailingOnes) && |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 350 | io_.EmitRepeated('0', trailingZeroes) && |
| 351 | io_.EmitRepeated(' ', trailingBlanks_) && EmitSuffix(edit); |
| 352 | } |
| 353 | } |
| 354 | |
| 355 | // 13.7.5.2.3 in F'2018 |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 356 | template <int binaryPrecision> |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 357 | DataEdit RealOutputEditing<binaryPrecision>::EditForGOutput(DataEdit edit) { |
| 358 | edit.descriptor = 'E'; |
peter klausler | 4fb679d | 2020-09-30 15:04:43 -0700 | [diff] [blame] | 359 | int significantDigits{ |
| 360 | edit.digits.value_or(BinaryFloatingPoint::decimalPrecision)}; // 'd' |
| 361 | if (!edit.width.has_value() || (*edit.width > 0 && significantDigits == 0)) { |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 362 | return edit; // Gw.0 -> Ew.0 for w > 0 |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 363 | } |
Peter Klausler | d1b09ad | 2021-11-10 14:02:30 -0800 | [diff] [blame] | 364 | int flags{0}; |
| 365 | if (edit.modes.editingFlags & signPlus) { |
| 366 | flags |= decimal::AlwaysSign; |
| 367 | } |
peter klausler | 4fb679d | 2020-09-30 15:04:43 -0700 | [diff] [blame] | 368 | decimal::ConversionToDecimalResult converted{ |
Peter Klausler | d1b09ad | 2021-11-10 14:02:30 -0800 | [diff] [blame] | 369 | Convert(significantDigits, edit.modes.round, flags)}; |
peter klausler | 0df6f8f | 2020-06-19 13:32:26 -0700 | [diff] [blame] | 370 | if (IsInfOrNaN(converted)) { |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 371 | return edit; |
| 372 | } |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 373 | int expo{IsZero() ? 1 : converted.decimalExponent}; // 's' |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 374 | if (expo < 0 || expo > significantDigits) { |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 375 | return edit; // Ew.d |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 376 | } |
| 377 | edit.descriptor = 'F'; |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 378 | edit.modes.scale = 0; // kP is ignored for G when no exponent field |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 379 | trailingBlanks_ = 0; |
| 380 | int editWidth{edit.width.value_or(0)}; |
| 381 | if (editWidth > 0) { |
| 382 | int expoDigits{edit.expoDigits.value_or(0)}; |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 383 | trailingBlanks_ = expoDigits > 0 ? expoDigits + 2 : 4; // 'n' |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 384 | *edit.width = std::max(0, editWidth - trailingBlanks_); |
| 385 | } |
| 386 | if (edit.digits.has_value()) { |
| 387 | *edit.digits = std::max(0, *edit.digits - expo); |
| 388 | } |
| 389 | return edit; |
| 390 | } |
| 391 | |
| 392 | // 13.10.4 in F'2018 |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 393 | template <int binaryPrecision> |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 394 | bool RealOutputEditing<binaryPrecision>::EditListDirectedOutput( |
| 395 | const DataEdit &edit) { |
Peter Klausler | d1b09ad | 2021-11-10 14:02:30 -0800 | [diff] [blame] | 396 | decimal::ConversionToDecimalResult converted{Convert(1, edit.modes.round)}; |
peter klausler | 0df6f8f | 2020-06-19 13:32:26 -0700 | [diff] [blame] | 397 | if (IsInfOrNaN(converted)) { |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 398 | return EditEorDOutput(edit); |
| 399 | } |
| 400 | int expo{converted.decimalExponent}; |
| 401 | if (expo < 0 || expo > BinaryFloatingPoint::decimalPrecision) { |
| 402 | DataEdit copy{edit}; |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 403 | copy.modes.scale = 1; // 1P |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 404 | return EditEorDOutput(copy); |
| 405 | } |
| 406 | return EditFOutput(edit); |
| 407 | } |
| 408 | |
| 409 | // 13.7.5.2.6 in F'2018 |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 410 | template <int binaryPrecision> |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 411 | bool RealOutputEditing<binaryPrecision>::EditEXOutput(const DataEdit &) { |
| 412 | io_.GetIoErrorHandler().Crash( |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 413 | "EX output editing is not yet implemented"); // TODO |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 414 | } |
| 415 | |
peter klausler | f65f830 | 2021-10-11 15:41:14 -0700 | [diff] [blame] | 416 | template <int KIND> bool RealOutputEditing<KIND>::Edit(const DataEdit &edit) { |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 417 | switch (edit.descriptor) { |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 418 | case 'D': |
| 419 | return EditEorDOutput(edit); |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 420 | case 'E': |
| 421 | if (edit.variation == 'X') { |
| 422 | return EditEXOutput(edit); |
| 423 | } else { |
| 424 | return EditEorDOutput(edit); |
| 425 | } |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 426 | case 'F': |
| 427 | return EditFOutput(edit); |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 428 | case 'B': |
| 429 | case 'O': |
| 430 | case 'Z': |
peter klausler | f65f830 | 2021-10-11 15:41:14 -0700 | [diff] [blame] | 431 | return EditIntegerOutput<KIND>(io_, edit, |
peter klausler | c5a5517 | 2021-10-12 18:57:58 -0700 | [diff] [blame] | 432 | static_cast<common::HostSignedIntType<8 * KIND>>( |
| 433 | decimal::BinaryFloatingPointNumber<binaryPrecision>{x_}.raw())); |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 434 | case 'G': |
| 435 | return Edit(EditForGOutput(edit)); |
peter klausler | b83242e | 2021-10-21 13:33:07 -0700 | [diff] [blame] | 436 | case 'A': // legacy extension |
| 437 | return EditDefaultCharacterOutput( |
| 438 | io_, edit, reinterpret_cast<char *>(&x_), sizeof x_); |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 439 | default: |
| 440 | if (edit.IsListDirected()) { |
| 441 | return EditListDirectedOutput(edit); |
| 442 | } |
| 443 | io_.GetIoErrorHandler().SignalError(IostatErrorInFormat, |
| 444 | "Data edit descriptor '%c' may not be used with a REAL data item", |
| 445 | edit.descriptor); |
| 446 | return false; |
| 447 | } |
| 448 | return false; |
| 449 | } |
| 450 | |
| 451 | bool ListDirectedLogicalOutput(IoStatementState &io, |
| 452 | ListDirectedStatementState<Direction::Output> &list, bool truth) { |
peter klausler | 6a1c3ef | 2021-05-05 11:37:49 -0700 | [diff] [blame] | 453 | return list.EmitLeadingSpaceOrAdvance(io) && io.Emit(truth ? "T" : "F", 1); |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 454 | } |
| 455 | |
| 456 | bool EditLogicalOutput(IoStatementState &io, const DataEdit &edit, bool truth) { |
| 457 | switch (edit.descriptor) { |
| 458 | case 'L': |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 459 | case 'G': |
peter klausler | e79a86e | 2020-07-17 11:14:28 -0700 | [diff] [blame] | 460 | return io.EmitRepeated(' ', std::max(0, edit.width.value_or(1) - 1)) && |
| 461 | io.Emit(truth ? "T" : "F", 1); |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 462 | default: |
| 463 | io.GetIoErrorHandler().SignalError(IostatErrorInFormat, |
| 464 | "Data edit descriptor '%c' may not be used with a LOGICAL data item", |
| 465 | edit.descriptor); |
| 466 | return false; |
| 467 | } |
| 468 | } |
| 469 | |
| 470 | bool ListDirectedDefaultCharacterOutput(IoStatementState &io, |
| 471 | ListDirectedStatementState<Direction::Output> &list, const char *x, |
| 472 | std::size_t length) { |
peter klausler | 6a1c3ef | 2021-05-05 11:37:49 -0700 | [diff] [blame] | 473 | bool ok{true}; |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 474 | MutableModes &modes{io.mutableModes()}; |
| 475 | ConnectionState &connection{io.GetConnectionState()}; |
| 476 | if (modes.delim) { |
peter klausler | 6a1c3ef | 2021-05-05 11:37:49 -0700 | [diff] [blame] | 477 | ok = ok && list.EmitLeadingSpaceOrAdvance(io); |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 478 | // Value is delimited with ' or " marks, and interior |
peter klausler | 4d42e16 | 2021-07-22 09:47:37 -0700 | [diff] [blame] | 479 | // instances of that character are doubled. |
peter klausler | 6a1c3ef | 2021-05-05 11:37:49 -0700 | [diff] [blame] | 480 | ok = ok && io.Emit(&modes.delim, 1); |
peter klausler | 4d42e16 | 2021-07-22 09:47:37 -0700 | [diff] [blame] | 481 | auto EmitOne{[&](char ch) { |
| 482 | if (connection.NeedAdvance(1)) { |
| 483 | ok = ok && io.AdvanceRecord(); |
| 484 | } |
| 485 | ok = ok && io.Emit(&ch, 1); |
| 486 | }}; |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 487 | for (std::size_t j{0}; j < length; ++j) { |
peter klausler | 4d42e16 | 2021-07-22 09:47:37 -0700 | [diff] [blame] | 488 | // Doubled delimiters must be put on the same record |
| 489 | // in order to be acceptable as list-directed or NAMELIST |
| 490 | // input; however, this requirement is not always possible |
| 491 | // when the records have a fixed length, as is the case with |
| 492 | // internal output. The standard is silent on what should |
| 493 | // happen, and no two extant Fortran implementations do |
| 494 | // the same thing when tested with this case. |
| 495 | // This runtime splits the doubled delimiters across |
| 496 | // two records for lack of a better alternative. |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 497 | if (x[j] == modes.delim) { |
peter klausler | 4d42e16 | 2021-07-22 09:47:37 -0700 | [diff] [blame] | 498 | EmitOne(x[j]); |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 499 | } |
peter klausler | 4d42e16 | 2021-07-22 09:47:37 -0700 | [diff] [blame] | 500 | EmitOne(x[j]); |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 501 | } |
peter klausler | 4d42e16 | 2021-07-22 09:47:37 -0700 | [diff] [blame] | 502 | EmitOne(modes.delim); |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 503 | } else { |
| 504 | // Undelimited list-directed output |
peter klausler | 6a1c3ef | 2021-05-05 11:37:49 -0700 | [diff] [blame] | 505 | ok = ok && |
| 506 | list.EmitLeadingSpaceOrAdvance( |
| 507 | io, length > 0 && !list.lastWasUndelimitedCharacter()); |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 508 | std::size_t put{0}; |
peter klausler | 6a1c3ef | 2021-05-05 11:37:49 -0700 | [diff] [blame] | 509 | while (ok && put < length) { |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 510 | auto chunk{std::min(length - put, connection.RemainingSpaceInRecord())}; |
peter klausler | 6a1c3ef | 2021-05-05 11:37:49 -0700 | [diff] [blame] | 511 | ok = ok && io.Emit(x + put, chunk); |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 512 | put += chunk; |
| 513 | if (put < length) { |
peter klausler | 6a1c3ef | 2021-05-05 11:37:49 -0700 | [diff] [blame] | 514 | ok = ok && io.AdvanceRecord() && io.Emit(" ", 1); |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 515 | } |
| 516 | } |
peter klausler | 6a1c3ef | 2021-05-05 11:37:49 -0700 | [diff] [blame] | 517 | list.set_lastWasUndelimitedCharacter(true); |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 518 | } |
| 519 | return ok; |
| 520 | } |
| 521 | |
| 522 | bool EditDefaultCharacterOutput(IoStatementState &io, const DataEdit &edit, |
| 523 | const char *x, std::size_t length) { |
| 524 | switch (edit.descriptor) { |
| 525 | case 'A': |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 526 | case 'G': |
| 527 | break; |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 528 | default: |
| 529 | io.GetIoErrorHandler().SignalError(IostatErrorInFormat, |
| 530 | "Data edit descriptor '%c' may not be used with a CHARACTER data item", |
| 531 | edit.descriptor); |
| 532 | return false; |
| 533 | } |
| 534 | int len{static_cast<int>(length)}; |
| 535 | int width{edit.width.value_or(len)}; |
| 536 | return io.EmitRepeated(' ', std::max(0, width - len)) && |
| 537 | io.Emit(x, std::min(width, len)); |
| 538 | } |
| 539 | |
peter klausler | f65f830 | 2021-10-11 15:41:14 -0700 | [diff] [blame] | 540 | template bool EditIntegerOutput<1>( |
| 541 | IoStatementState &, const DataEdit &, std::int8_t); |
| 542 | template bool EditIntegerOutput<2>( |
| 543 | IoStatementState &, const DataEdit &, std::int16_t); |
| 544 | template bool EditIntegerOutput<4>( |
| 545 | IoStatementState &, const DataEdit &, std::int32_t); |
| 546 | template bool EditIntegerOutput<8>( |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 547 | IoStatementState &, const DataEdit &, std::int64_t); |
peter klausler | f65f830 | 2021-10-11 15:41:14 -0700 | [diff] [blame] | 548 | template bool EditIntegerOutput<16>( |
| 549 | IoStatementState &, const DataEdit &, common::int128_t); |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 550 | |
peter klausler | d56fdc8 | 2020-10-02 12:39:05 -0700 | [diff] [blame] | 551 | template class RealOutputEditing<2>; |
| 552 | template class RealOutputEditing<3>; |
| 553 | template class RealOutputEditing<4>; |
peter klausler | 3b63571 | 2020-02-13 14:41:56 -0800 | [diff] [blame] | 554 | template class RealOutputEditing<8>; |
peter klausler | d56fdc8 | 2020-10-02 12:39:05 -0700 | [diff] [blame] | 555 | template class RealOutputEditing<10>; |
| 556 | // TODO: double/double |
| 557 | template class RealOutputEditing<16>; |
Tim Keith | 1f87900 | 2020-03-28 21:00:16 -0700 | [diff] [blame] | 558 | } // namespace Fortran::runtime::io |