1//===- NativeFormatting.cpp - Low level formatting helpers -------*- C++-*-===//
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 "llvm/Support/NativeFormatting.h"
10
11#include "llvm/ADT/ArrayRef.h"
12#include "llvm/ADT/SmallString.h"
13#include "llvm/ADT/StringExtras.h"
14#include "llvm/Support/Format.h"
15
16#include <float.h>
17
18using namespace llvm;
19
20template<typename T, std::size_t N>
21static int format_to_buffer(T Value, char (&Buffer)[N]) {
22  char *EndPtr = std::end(Buffer);
23  char *CurPtr = EndPtr;
24
25  do {
26    *--CurPtr = '0' + char(Value % 10);
27    Value /= 10;
28  } while (Value);
29  return EndPtr - CurPtr;
30}
31
32static void writeWithCommas(raw_ostream &S, ArrayRef<char> Buffer) {
33  assert(!Buffer.empty());
34
35  ArrayRef<char> ThisGroup;
36  int InitialDigits = ((Buffer.size() - 1) % 3) + 1;
37  ThisGroup = Buffer.take_front(InitialDigits);
38  S.write(ThisGroup.data(), ThisGroup.size());
39
40  Buffer = Buffer.drop_front(InitialDigits);
41  assert(Buffer.size() % 3 == 0);
42  while (!Buffer.empty()) {
43    S << ',';
44    ThisGroup = Buffer.take_front(3);
45    S.write(ThisGroup.data(), 3);
46    Buffer = Buffer.drop_front(3);
47  }
48}
49
50template <typename T>
51static void write_unsigned_impl(raw_ostream &S, T N, size_t MinDigits,
52                                IntegerStyle Style, bool IsNegative) {
53  static_assert(std::is_unsigned<T>::value, "Value is not unsigned!");
54
55  char NumberBuffer[128];
56  std::memset(NumberBuffer, '0', sizeof(NumberBuffer));
57
58  size_t Len = 0;
59  Len = format_to_buffer(N, NumberBuffer);
60
61  if (IsNegative)
62    S << '-';
63
64  if (Len < MinDigits && Style != IntegerStyle::Number) {
65    for (size_t I = Len; I < MinDigits; ++I)
66      S << '0';
67  }
68
69  if (Style == IntegerStyle::Number) {
70    writeWithCommas(S, ArrayRef<char>(std::end(NumberBuffer) - Len, Len));
71  } else {
72    S.write(std::end(NumberBuffer) - Len, Len);
73  }
74}
75
76template <typename T>
77static void write_unsigned(raw_ostream &S, T N, size_t MinDigits,
78                           IntegerStyle Style, bool IsNegative = false) {
79  // Output using 32-bit div/mod if possible.
80  if (N == static_cast<uint32_t>(N))
81    write_unsigned_impl(S, static_cast<uint32_t>(N), MinDigits, Style,
82                        IsNegative);
83  else
84    write_unsigned_impl(S, N, MinDigits, Style, IsNegative);
85}
86
87template <typename T>
88static void write_signed(raw_ostream &S, T N, size_t MinDigits,
89                         IntegerStyle Style) {
90  static_assert(std::is_signed<T>::value, "Value is not signed!");
91
92  using UnsignedT = typename std::make_unsigned<T>::type;
93
94  if (N >= 0) {
95    write_unsigned(S, static_cast<UnsignedT>(N), MinDigits, Style);
96    return;
97  }
98
99  UnsignedT UN = -(UnsignedT)N;
100  write_unsigned(S, UN, MinDigits, Style, true);
101}
102
103void llvm::write_integer(raw_ostream &S, unsigned int N, size_t MinDigits,
104                         IntegerStyle Style) {
105  write_unsigned(S, N, MinDigits, Style);
106}
107
108void llvm::write_integer(raw_ostream &S, int N, size_t MinDigits,
109                         IntegerStyle Style) {
110  write_signed(S, N, MinDigits, Style);
111}
112
113void llvm::write_integer(raw_ostream &S, unsigned long N, size_t MinDigits,
114                         IntegerStyle Style) {
115  write_unsigned(S, N, MinDigits, Style);
116}
117
118void llvm::write_integer(raw_ostream &S, long N, size_t MinDigits,
119                         IntegerStyle Style) {
120  write_signed(S, N, MinDigits, Style);
121}
122
123void llvm::write_integer(raw_ostream &S, unsigned long long N, size_t MinDigits,
124                         IntegerStyle Style) {
125  write_unsigned(S, N, MinDigits, Style);
126}
127
128void llvm::write_integer(raw_ostream &S, long long N, size_t MinDigits,
129                         IntegerStyle Style) {
130  write_signed(S, N, MinDigits, Style);
131}
132
133void llvm::write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style,
134                     Optional<size_t> Width) {
135  const size_t kMaxWidth = 128u;
136
137  size_t W = std::min(kMaxWidth, Width.getValueOr(0u));
138
139  unsigned Nibbles = (64 - countLeadingZeros(N) + 3) / 4;
140  bool Prefix = (Style == HexPrintStyle::PrefixLower ||
141                 Style == HexPrintStyle::PrefixUpper);
142  bool Upper =
143      (Style == HexPrintStyle::Upper || Style == HexPrintStyle::PrefixUpper);
144  unsigned PrefixChars = Prefix ? 2 : 0;
145  unsigned NumChars =
146      std::max(static_cast<unsigned>(W), std::max(1u, Nibbles) + PrefixChars);
147
148  char NumberBuffer[kMaxWidth];
149  ::memset(NumberBuffer, '0', llvm::array_lengthof(NumberBuffer));
150  if (Prefix)
151    NumberBuffer[1] = 'x';
152  char *EndPtr = NumberBuffer + NumChars;
153  char *CurPtr = EndPtr;
154  while (N) {
155    unsigned char x = static_cast<unsigned char>(N) % 16;
156    *--CurPtr = hexdigit(x, !Upper);
157    N /= 16;
158  }
159
160  S.write(NumberBuffer, NumChars);
161}
162
163void llvm::write_double(raw_ostream &S, double N, FloatStyle Style,
164                        Optional<size_t> Precision) {
165  size_t Prec = Precision.getValueOr(getDefaultPrecision(Style));
166
167  if (std::isnan(N)) {
168    S << "nan";
169    return;
170  } else if (std::isinf(N)) {
171    S << "INF";
172    return;
173  }
174
175  char Letter;
176  if (Style == FloatStyle::Exponent)
177    Letter = 'e';
178  else if (Style == FloatStyle::ExponentUpper)
179    Letter = 'E';
180  else
181    Letter = 'f';
182
183  SmallString<8> Spec;
184  llvm::raw_svector_ostream Out(Spec);
185  Out << "%." << Prec << Letter;
186
187  if (Style == FloatStyle::Exponent || Style == FloatStyle::ExponentUpper) {
188#ifdef _WIN32
189// On MSVCRT and compatible, output of %e is incompatible to Posix
190// by default. Number of exponent digits should be at least 2. "%+03d"
191// FIXME: Implement our formatter to here or Support/Format.h!
192#if defined(__MINGW32__)
193    // FIXME: It should be generic to C++11.
194    if (N == 0.0 && std::signbit(N)) {
195      char NegativeZero[] = "-0.000000e+00";
196      if (Style == FloatStyle::ExponentUpper)
197        NegativeZero[strlen(NegativeZero) - 4] = 'E';
198      S << NegativeZero;
199      return;
200    }
201#else
202    int fpcl = _fpclass(N);
203
204    // negative zero
205    if (fpcl == _FPCLASS_NZ) {
206      char NegativeZero[] = "-0.000000e+00";
207      if (Style == FloatStyle::ExponentUpper)
208        NegativeZero[strlen(NegativeZero) - 4] = 'E';
209      S << NegativeZero;
210      return;
211    }
212#endif
213
214    char buf[32];
215    unsigned len;
216    len = format(Spec.c_str(), N).snprint(buf, sizeof(buf));
217    if (len <= sizeof(buf) - 2) {
218      if (len >= 5 && (buf[len - 5] == 'e' || buf[len - 5] == 'E') &&
219          buf[len - 3] == '0') {
220        int cs = buf[len - 4];
221        if (cs == '+' || cs == '-') {
222          int c1 = buf[len - 2];
223          int c0 = buf[len - 1];
224          if (isdigit(static_cast<unsigned char>(c1)) &&
225              isdigit(static_cast<unsigned char>(c0))) {
226            // Trim leading '0': "...e+012" -> "...e+12\0"
227            buf[len - 3] = c1;
228            buf[len - 2] = c0;
229            buf[--len] = 0;
230          }
231        }
232      }
233      S << buf;
234      return;
235    }
236#endif
237  }
238
239  if (Style == FloatStyle::Percent)
240    N *= 100.0;
241
242  char Buf[32];
243  format(Spec.c_str(), N).snprint(Buf, sizeof(Buf));
244  S << Buf;
245  if (Style == FloatStyle::Percent)
246    S << '%';
247}
248
249bool llvm::isPrefixedHexStyle(HexPrintStyle S) {
250  return (S == HexPrintStyle::PrefixLower || S == HexPrintStyle::PrefixUpper);
251}
252
253size_t llvm::getDefaultPrecision(FloatStyle Style) {
254  switch (Style) {
255  case FloatStyle::Exponent:
256  case FloatStyle::ExponentUpper:
257    return 6; // Number of decimal places.
258  case FloatStyle::Fixed:
259  case FloatStyle::Percent:
260    return 2; // Number of decimal places.
261  }
262  LLVM_BUILTIN_UNREACHABLE;
263}
264