1 // -*- C++ -*-
2 //===----------------------------------------------------------------------===//
3 //
4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5 // See https://llvm.org/LICENSE.txt for license information.
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #ifndef _LIBCPP___CHARCONV_TO_CHARS_INTEGRAL_H
11 #define _LIBCPP___CHARCONV_TO_CHARS_INTEGRAL_H
12 
13 #include <__algorithm/copy_n.h>
14 #include <__bit/countl.h>
15 #include <__charconv/tables.h>
16 #include <__charconv/to_chars_base_10.h>
17 #include <__charconv/to_chars_result.h>
18 #include <__charconv/traits.h>
19 #include <__config>
20 #include <__system_error/errc.h>
21 #include <__type_traits/enable_if.h>
22 #include <__type_traits/integral_constant.h>
23 #include <__type_traits/is_same.h>
24 #include <__type_traits/make_32_64_or_128_bit.h>
25 #include <__type_traits/make_unsigned.h>
26 #include <__utility/unreachable.h>
27 #include <cstddef>
28 #include <cstdint>
29 #include <limits>
30 
31 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
32 #  pragma GCC system_header
33 #endif
34 
35 _LIBCPP_PUSH_MACROS
36 #include <__undef_macros>
37 
38 _LIBCPP_BEGIN_NAMESPACE_STD
39 
40 #if _LIBCPP_STD_VER >= 17
41 
42 to_chars_result to_chars(char*, char*, bool, int = 10) = delete;
43 
44 template <typename _Tp>
45 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
46 __to_chars_itoa(char* __first, char* __last, _Tp __value, false_type);
47 
48 template <typename _Tp>
49 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
50 __to_chars_itoa(char* __first, char* __last, _Tp __value, true_type) {
51   auto __x = std::__to_unsigned_like(__value);
52   if (__value < 0 && __first != __last) {
53     *__first++ = '-';
54     __x        = std::__complement(__x);
55   }
56 
57   return std::__to_chars_itoa(__first, __last, __x, false_type());
58 }
59 
60 template <typename _Tp>
61 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
62 __to_chars_itoa(char* __first, char* __last, _Tp __value, false_type) {
63   using __tx  = __itoa::__traits<_Tp>;
64   auto __diff = __last - __first;
65 
66   if (__tx::digits <= __diff || __tx::__width(__value) <= __diff)
67     return {__tx::__convert(__first, __value), errc(0)};
68   else
69     return {__last, errc::value_too_large};
70 }
71 
72 #  ifndef _LIBCPP_HAS_NO_INT128
73 template <>
74 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
75 __to_chars_itoa(char* __first, char* __last, __uint128_t __value, false_type) {
76   // When the value fits in 64-bits use the 64-bit code path. This reduces
77   // the number of expensive calculations on 128-bit values.
78   //
79   // NOTE the 128-bit code path requires this optimization.
80   if (__value <= numeric_limits<uint64_t>::max())
81     return __to_chars_itoa(__first, __last, static_cast<uint64_t>(__value), false_type());
82 
83   using __tx  = __itoa::__traits<__uint128_t>;
84   auto __diff = __last - __first;
85 
86   if (__tx::digits <= __diff || __tx::__width(__value) <= __diff)
87     return {__tx::__convert(__first, __value), errc(0)};
88   else
89     return {__last, errc::value_too_large};
90 }
91 #  endif
92 
93 template <class _Tp>
94 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
95 __to_chars_integral(char* __first, char* __last, _Tp __value, int __base, false_type);
96 
97 template <typename _Tp>
98 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
99 __to_chars_integral(char* __first, char* __last, _Tp __value, int __base, true_type) {
100   auto __x = std::__to_unsigned_like(__value);
101   if (__value < 0 && __first != __last) {
102     *__first++ = '-';
103     __x        = std::__complement(__x);
104   }
105 
106   return std::__to_chars_integral(__first, __last, __x, __base, false_type());
107 }
108 
109 namespace __itoa {
110 
111 template <unsigned _Base>
112 struct _LIBCPP_HIDDEN __integral;
113 
114 template <>
115 struct _LIBCPP_HIDDEN __integral<2> {
116   template <typename _Tp>
117   _LIBCPP_HIDE_FROM_ABI static constexpr int __width(_Tp __value) noexcept {
118     // If value == 0 still need one digit. If the value != this has no
119     // effect since the code scans for the most significant bit set. (Note
120     // that __libcpp_clz doesn't work for 0.)
121     return numeric_limits<_Tp>::digits - std::__libcpp_clz(__value | 1);
122   }
123 
124   template <typename _Tp>
125   _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI static to_chars_result
126   __to_chars(char* __first, char* __last, _Tp __value) {
127     ptrdiff_t __cap = __last - __first;
128     int __n         = __width(__value);
129     if (__n > __cap)
130       return {__last, errc::value_too_large};
131 
132     __last                   = __first + __n;
133     char* __p                = __last;
134     const unsigned __divisor = 16;
135     while (__value > __divisor) {
136       unsigned __c = __value % __divisor;
137       __value /= __divisor;
138       __p -= 4;
139       std::copy_n(&__base_2_lut[4 * __c], 4, __p);
140     }
141     do {
142       unsigned __c = __value % 2;
143       __value /= 2;
144       *--__p = "01"[__c];
145     } while (__value != 0);
146     return {__last, errc(0)};
147   }
148 };
149 
150 template <>
151 struct _LIBCPP_HIDDEN __integral<8> {
152   template <typename _Tp>
153   _LIBCPP_HIDE_FROM_ABI static constexpr int __width(_Tp __value) noexcept {
154     // If value == 0 still need one digit. If the value != this has no
155     // effect since the code scans for the most significat bit set. (Note
156     // that __libcpp_clz doesn't work for 0.)
157     return ((numeric_limits<_Tp>::digits - std::__libcpp_clz(__value | 1)) + 2) / 3;
158   }
159 
160   template <typename _Tp>
161   _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI static to_chars_result
162   __to_chars(char* __first, char* __last, _Tp __value) {
163     ptrdiff_t __cap = __last - __first;
164     int __n         = __width(__value);
165     if (__n > __cap)
166       return {__last, errc::value_too_large};
167 
168     __last             = __first + __n;
169     char* __p          = __last;
170     unsigned __divisor = 64;
171     while (__value > __divisor) {
172       unsigned __c = __value % __divisor;
173       __value /= __divisor;
174       __p -= 2;
175       std::copy_n(&__base_8_lut[2 * __c], 2, __p);
176     }
177     do {
178       unsigned __c = __value % 8;
179       __value /= 8;
180       *--__p = "01234567"[__c];
181     } while (__value != 0);
182     return {__last, errc(0)};
183   }
184 };
185 
186 template <>
187 struct _LIBCPP_HIDDEN __integral<16> {
188   template <typename _Tp>
189   _LIBCPP_HIDE_FROM_ABI static constexpr int __width(_Tp __value) noexcept {
190     // If value == 0 still need one digit. If the value != this has no
191     // effect since the code scans for the most significat bit set. (Note
192     // that __libcpp_clz doesn't work for 0.)
193     return (numeric_limits<_Tp>::digits - std::__libcpp_clz(__value | 1) + 3) / 4;
194   }
195 
196   template <typename _Tp>
197   _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI static to_chars_result
198   __to_chars(char* __first, char* __last, _Tp __value) {
199     ptrdiff_t __cap = __last - __first;
200     int __n         = __width(__value);
201     if (__n > __cap)
202       return {__last, errc::value_too_large};
203 
204     __last             = __first + __n;
205     char* __p          = __last;
206     unsigned __divisor = 256;
207     while (__value > __divisor) {
208       unsigned __c = __value % __divisor;
209       __value /= __divisor;
210       __p -= 2;
211       std::copy_n(&__base_16_lut[2 * __c], 2, __p);
212     }
213     if (__first != __last)
214       do {
215         unsigned __c = __value % 16;
216         __value /= 16;
217         *--__p = "0123456789abcdef"[__c];
218       } while (__value != 0);
219     return {__last, errc(0)};
220   }
221 };
222 
223 } // namespace __itoa
224 
225 template <unsigned _Base, typename _Tp, typename enable_if<(sizeof(_Tp) >= sizeof(unsigned)), int>::type = 0>
226 _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI int __to_chars_integral_width(_Tp __value) {
227   return __itoa::__integral<_Base>::__width(__value);
228 }
229 
230 template <unsigned _Base, typename _Tp, typename enable_if<(sizeof(_Tp) < sizeof(unsigned)), int>::type = 0>
231 _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI int __to_chars_integral_width(_Tp __value) {
232   return std::__to_chars_integral_width<_Base>(static_cast<unsigned>(__value));
233 }
234 
235 template <unsigned _Base, typename _Tp, typename enable_if<(sizeof(_Tp) >= sizeof(unsigned)), int>::type = 0>
236 _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
237 __to_chars_integral(char* __first, char* __last, _Tp __value) {
238   return __itoa::__integral<_Base>::__to_chars(__first, __last, __value);
239 }
240 
241 template <unsigned _Base, typename _Tp, typename enable_if<(sizeof(_Tp) < sizeof(unsigned)), int>::type = 0>
242 _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
243 __to_chars_integral(char* __first, char* __last, _Tp __value) {
244   return std::__to_chars_integral<_Base>(__first, __last, static_cast<unsigned>(__value));
245 }
246 
247 template <typename _Tp>
248 _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI int __to_chars_integral_width(_Tp __value, unsigned __base) {
249   _LIBCPP_ASSERT_UNCATEGORIZED(__value >= 0, "The function requires a non-negative value.");
250 
251   unsigned __base_2 = __base * __base;
252   unsigned __base_3 = __base_2 * __base;
253   unsigned __base_4 = __base_2 * __base_2;
254 
255   int __r = 0;
256   while (true) {
257     if (__value < __base)
258       return __r + 1;
259     if (__value < __base_2)
260       return __r + 2;
261     if (__value < __base_3)
262       return __r + 3;
263     if (__value < __base_4)
264       return __r + 4;
265 
266     __value /= __base_4;
267     __r += 4;
268   }
269 
270   __libcpp_unreachable();
271 }
272 
273 template <typename _Tp>
274 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
275 __to_chars_integral(char* __first, char* __last, _Tp __value, int __base, false_type) {
276   if (__base == 10) [[likely]]
277     return std::__to_chars_itoa(__first, __last, __value, false_type());
278 
279   switch (__base) {
280   case 2:
281     return std::__to_chars_integral<2>(__first, __last, __value);
282   case 8:
283     return std::__to_chars_integral<8>(__first, __last, __value);
284   case 16:
285     return std::__to_chars_integral<16>(__first, __last, __value);
286   }
287 
288   ptrdiff_t __cap = __last - __first;
289   int __n         = std::__to_chars_integral_width(__value, __base);
290   if (__n > __cap)
291     return {__last, errc::value_too_large};
292 
293   __last    = __first + __n;
294   char* __p = __last;
295   do {
296     unsigned __c = __value % __base;
297     __value /= __base;
298     *--__p = "0123456789abcdefghijklmnopqrstuvwxyz"[__c];
299   } while (__value != 0);
300   return {__last, errc(0)};
301 }
302 
303 template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
304 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
305 to_chars(char* __first, char* __last, _Tp __value) {
306   using _Type = __make_32_64_or_128_bit_t<_Tp>;
307   static_assert(!is_same<_Type, void>::value, "unsupported integral type used in to_chars");
308   return std::__to_chars_itoa(__first, __last, static_cast<_Type>(__value), is_signed<_Tp>());
309 }
310 
311 template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
312 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
313 to_chars(char* __first, char* __last, _Tp __value, int __base) {
314   _LIBCPP_ASSERT_UNCATEGORIZED(2 <= __base && __base <= 36, "base not in [2, 36]");
315 
316   using _Type = __make_32_64_or_128_bit_t<_Tp>;
317   return std::__to_chars_integral(__first, __last, static_cast<_Type>(__value), __base, is_signed<_Tp>());
318 }
319 
320 #endif // _LIBCPP_STD_VER >= 17
321 
322 _LIBCPP_END_NAMESPACE_STD
323 
324 _LIBCPP_POP_MACROS
325 
326 #endif // _LIBCPP___CHARCONV_TO_CHARS_INTEGRAL_H
327