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