1 // Primitive numeric conversions (to_chars and from_chars) -*- C++ -*-
3 // Copyright (C) 2017-2020 Free Software Foundation, Inc.
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
25 /** @file include/charconv
26 * This is a Standard C++ Library header.
29 #ifndef _GLIBCXX_CHARCONV
30 #define _GLIBCXX_CHARCONV 1
32 #pragma GCC system_header
34 // As an extension we support <charconv> in C++14, but this header should not
35 // be included by any other library headers in C++14 mode. This ensures that
36 // the names defined in this header are not added to namespace std unless a
37 // user explicitly includes <charconv> in C++14 code.
38 #if __cplusplus >= 201402L
40 #include <type_traits>
41 #include <bit> // for __bit_width
42 #include <cctype> // for isdigit
43 #include <bits/charconv.h> // for __to_chars_len, __to_chars_10_impl
44 #include <bits/error_constants.h> // for std::errc
45 #include <bits/int_limits.h>
47 // FIXME: Define when floating point is supported:
48 // #define __cpp_lib_to_chars 201611L
50 namespace std _GLIBCXX_VISIBILITY(default)
52 _GLIBCXX_BEGIN_NAMESPACE_VERSION
54 /// Result type of std::to_chars
55 struct to_chars_result
60 #if __cplusplus > 201703L && __cpp_impl_three_way_comparison >= 201907L
62 operator==(const to_chars_result&, const to_chars_result&) = default;
66 /// Result type of std::from_chars
67 struct from_chars_result
72 #if __cplusplus > 201703L && __cpp_impl_three_way_comparison >= 201907L
74 operator==(const from_chars_result&, const from_chars_result&) = default;
80 template<typename _Tp>
81 using __integer_to_chars_result_type
82 = enable_if_t<__or_<__is_signed_integer<_Tp>,
83 __is_unsigned_integer<_Tp>,
84 is_same<char, remove_cv_t<_Tp>>>::value,
87 // Pick an unsigned type of suitable size. This is used to reduce the
88 // number of specializations of __to_chars_len, __to_chars etc. that
89 // get instantiated. For example, to_chars<char> and to_chars<short>
90 // and to_chars<unsigned> will all use the same code, and so will
91 // to_chars<long> when sizeof(int) == sizeof(long).
92 template<typename _Tp>
93 struct __to_chars_unsigned_type : __make_unsigned_selector_base
95 using _UInts = _List<unsigned int, unsigned long, unsigned long long
96 #if _GLIBCXX_USE_INT128
100 using type = typename __select<sizeof(_Tp), _UInts>::__type;
103 template<typename _Tp>
104 using __unsigned_least_t = typename __to_chars_unsigned_type<_Tp>::type;
106 // Generic implementation for arbitrary bases.
107 // Defined in <bits/charconv.h>.
108 template<typename _Tp>
110 __to_chars_len(_Tp __value, int __base /* = 10 */) noexcept;
112 template<typename _Tp>
114 __to_chars_len_2(_Tp __value) noexcept
115 { return std::__bit_width(__value); }
117 // Generic implementation for arbitrary bases.
118 template<typename _Tp>
120 __to_chars(char* __first, char* __last, _Tp __val, int __base) noexcept
122 static_assert(is_integral<_Tp>::value, "implementation bug");
123 static_assert(is_unsigned<_Tp>::value, "implementation bug");
125 to_chars_result __res;
127 const unsigned __len = __to_chars_len(__val, __base);
129 if (__builtin_expect((__last - __first) < __len, 0))
132 __res.ec = errc::value_too_large;
136 unsigned __pos = __len - 1;
138 static constexpr char __digits[] = {
139 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
140 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
141 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
142 'u', 'v', 'w', 'x', 'y', 'z'
145 while (__val >= __base)
147 auto const __quo = __val / __base;
148 auto const __rem = __val % __base;
149 __first[__pos--] = __digits[__rem];
152 *__first = __digits[__val];
154 __res.ptr = __first + __len;
159 template<typename _Tp>
160 __integer_to_chars_result_type<_Tp>
161 __to_chars_16(char* __first, char* __last, _Tp __val) noexcept
163 static_assert(is_integral<_Tp>::value, "implementation bug");
164 static_assert(is_unsigned<_Tp>::value, "implementation bug");
166 to_chars_result __res;
168 const unsigned __len = (__to_chars_len_2(__val) + 3) / 4;
170 if (__builtin_expect((__last - __first) < __len, 0))
173 __res.ec = errc::value_too_large;
177 static constexpr char __digits[] = {
178 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
179 'a', 'b', 'c', 'd', 'e', 'f'
181 unsigned __pos = __len - 1;
182 while (__val >= 0x100)
184 auto __num = __val & 0xF;
186 __first[__pos] = __digits[__num];
189 __first[__pos - 1] = __digits[__num];
194 const auto __num = __val & 0xF;
196 __first[1] = __digits[__num];
197 __first[0] = __digits[__val];
200 __first[0] = __digits[__val];
201 __res.ptr = __first + __len;
206 template<typename _Tp>
207 inline __integer_to_chars_result_type<_Tp>
208 __to_chars_10(char* __first, char* __last, _Tp __val) noexcept
210 static_assert(is_integral<_Tp>::value, "implementation bug");
211 static_assert(is_unsigned<_Tp>::value, "implementation bug");
213 to_chars_result __res;
215 const unsigned __len = __to_chars_len(__val, 10);
217 if (__builtin_expect((__last - __first) < __len, 0))
220 __res.ec = errc::value_too_large;
224 __detail::__to_chars_10_impl(__first, __len, __val);
225 __res.ptr = __first + __len;
230 template<typename _Tp>
231 __integer_to_chars_result_type<_Tp>
232 __to_chars_8(char* __first, char* __last, _Tp __val) noexcept
234 static_assert(is_integral<_Tp>::value, "implementation bug");
235 static_assert(is_unsigned<_Tp>::value, "implementation bug");
237 to_chars_result __res;
240 if _GLIBCXX17_CONSTEXPR (__detail::__int_limits<_Tp>::digits <= 16)
242 __len = __val > 077777u ? 6u
243 : __val > 07777u ? 5u
250 __len = (__to_chars_len_2(__val) + 2) / 3;
252 if (__builtin_expect((__last - __first) < __len, 0))
255 __res.ec = errc::value_too_large;
259 unsigned __pos = __len - 1;
260 while (__val >= 0100)
262 auto __num = __val & 7;
264 __first[__pos] = '0' + __num;
267 __first[__pos - 1] = '0' + __num;
272 auto const __num = __val & 7;
274 __first[1] = '0' + __num;
275 __first[0] = '0' + __val;
278 __first[0] = '0' + __val;
279 __res.ptr = __first + __len;
284 template<typename _Tp>
285 __integer_to_chars_result_type<_Tp>
286 __to_chars_2(char* __first, char* __last, _Tp __val) noexcept
288 static_assert(is_integral<_Tp>::value, "implementation bug");
289 static_assert(is_unsigned<_Tp>::value, "implementation bug");
291 to_chars_result __res;
293 const unsigned __len = __to_chars_len_2(__val);
295 if (__builtin_expect((__last - __first) < __len, 0))
298 __res.ec = errc::value_too_large;
302 unsigned __pos = __len - 1;
306 __first[__pos--] = '0' + (__val & 1);
309 // First digit is always '1' because __to_chars_len_2 skips
310 // leading zero bits and std::to_chars handles zero values
314 __res.ptr = __first + __len;
319 } // namespace __detail
321 template<typename _Tp>
322 __detail::__integer_to_chars_result_type<_Tp>
323 __to_chars_i(char* __first, char* __last, _Tp __value, int __base = 10)
325 __glibcxx_assert(2 <= __base && __base <= 36);
327 using _Up = __detail::__unsigned_least_t<_Tp>;
328 _Up __unsigned_val = __value;
330 if (__value == 0 && __first != __last)
333 return { __first + 1, errc{} };
336 if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
339 if (__builtin_expect(__first != __last, 1))
341 __unsigned_val = _Up(~__value) + _Up(1);
347 return __detail::__to_chars_16(__first, __last, __unsigned_val);
349 return __detail::__to_chars_10(__first, __last, __unsigned_val);
351 return __detail::__to_chars_8(__first, __last, __unsigned_val);
353 return __detail::__to_chars_2(__first, __last, __unsigned_val);
355 return __detail::__to_chars(__first, __last, __unsigned_val, __base);
359 #define _GLIBCXX_TO_CHARS(T) \
360 inline to_chars_result \
361 to_chars(char* __first, char* __last, T __value, int __base = 10) \
362 { return std::__to_chars_i<T>(__first, __last, __value, __base); }
363 _GLIBCXX_TO_CHARS(char)
364 _GLIBCXX_TO_CHARS(signed char)
365 _GLIBCXX_TO_CHARS(unsigned char)
366 _GLIBCXX_TO_CHARS(signed short)
367 _GLIBCXX_TO_CHARS(unsigned short)
368 _GLIBCXX_TO_CHARS(signed int)
369 _GLIBCXX_TO_CHARS(unsigned int)
370 _GLIBCXX_TO_CHARS(signed long)
371 _GLIBCXX_TO_CHARS(unsigned long)
372 _GLIBCXX_TO_CHARS(signed long long)
373 _GLIBCXX_TO_CHARS(unsigned long long)
374 #if defined(__GLIBCXX_TYPE_INT_N_0)
375 _GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_0)
376 _GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_0)
378 #if defined(__GLIBCXX_TYPE_INT_N_1)
379 _GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_1)
380 _GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_1)
382 #if defined(__GLIBCXX_TYPE_INT_N_2)
383 _GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_2)
384 _GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_2)
386 #if defined(__GLIBCXX_TYPE_INT_N_3)
387 _GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_3)
388 _GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_3)
390 #undef _GLIBCXX_TO_CHARS
392 // _GLIBCXX_RESOLVE_LIB_DEFECTS
393 // 3266. to_chars(bool) should be deleted
394 to_chars_result to_chars(char*, char*, bool, int = 10) = delete;
398 template<typename _Tp>
400 __raise_and_add(_Tp& __val, int __base, unsigned char __c)
402 if (__builtin_mul_overflow(__val, __base, &__val)
403 || __builtin_add_overflow(__val, __c, &__val))
408 /// std::from_chars implementation for integers in base 2.
409 template<typename _Tp>
411 __from_chars_binary(const char*& __first, const char* __last, _Tp& __val)
413 static_assert(is_integral<_Tp>::value, "implementation bug");
414 static_assert(is_unsigned<_Tp>::value, "implementation bug");
416 const ptrdiff_t __len = __last - __first;
420 const unsigned char __c = (unsigned)__first[__i] - '0';
422 __val = (__val << 1) | __c;
428 return __i <= __detail::__int_limits<_Tp>::digits;
431 /// std::from_chars implementation for integers in bases 3 to 10.
432 template<typename _Tp>
434 __from_chars_digit(const char*& __first, const char* __last, _Tp& __val,
437 static_assert(is_integral<_Tp>::value, "implementation bug");
438 static_assert(is_unsigned<_Tp>::value, "implementation bug");
440 auto __matches = [__base](char __c) {
441 return '0' <= __c && __c <= ('0' + (__base - 1));
444 while (__first != __last)
446 const char __c = *__first;
449 if (!__raise_and_add(__val, __base, __c - '0'))
451 while (++__first != __last && __matches(*__first))
463 constexpr unsigned char
464 __from_chars_alpha_to_num(char __c)
547 return __detail::__int_limits<unsigned char>::max();
550 /// std::from_chars implementation for integers in bases 11 to 26.
551 template<typename _Tp>
553 __from_chars_alnum(const char*& __first, const char* __last, _Tp& __val,
557 while (__first != __last)
559 unsigned char __c = *__first;
560 if (std::isdigit(__c))
564 __c = __from_chars_alpha_to_num(__c);
569 if (__builtin_expect(__valid, 1))
570 __valid = __raise_and_add(__val, __base, __c);
576 template<typename _Tp>
577 using __integer_from_chars_result_type
578 = enable_if_t<__or_<__is_signed_integer<_Tp>,
579 __is_unsigned_integer<_Tp>,
580 is_same<char, remove_cv_t<_Tp>>>::value,
583 } // namespace __detail
585 /// std::from_chars for integral types.
586 template<typename _Tp>
587 __detail::__integer_from_chars_result_type<_Tp>
588 from_chars(const char* __first, const char* __last, _Tp& __value,
591 __glibcxx_assert(2 <= __base && __base <= 36);
593 from_chars_result __res{__first, {}};
596 if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
597 if (__first != __last && *__first == '-')
603 using _Up = __detail::__unsigned_least_t<_Tp>;
606 const auto __start = __first;
609 __valid = __detail::__from_chars_binary(__first, __last, __val);
610 else if (__base <= 10)
611 __valid = __detail::__from_chars_digit(__first, __last, __val, __base);
613 __valid = __detail::__from_chars_alnum(__first, __last, __val, __base);
615 if (__builtin_expect(__first == __start, 0))
616 __res.ec = errc::invalid_argument;
621 __res.ec = errc::result_out_of_range;
624 if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
627 if (__builtin_mul_overflow(__val, __sign, &__tmp))
628 __res.ec = errc::result_out_of_range;
634 if _GLIBCXX17_CONSTEXPR (__detail::__int_limits<_Up>::max()
635 > __detail::__int_limits<_Tp>::max())
637 if (__val > __detail::__int_limits<_Tp>::max())
638 __res.ec = errc::result_out_of_range;
650 /// floating-point format for primitive numerical conversion
651 enum class chars_format
653 scientific = 1, fixed = 2, hex = 4, general = fixed | scientific
656 constexpr chars_format
657 operator|(chars_format __lhs, chars_format __rhs) noexcept
658 { return (chars_format)((unsigned)__lhs | (unsigned)__rhs); }
660 constexpr chars_format
661 operator&(chars_format __lhs, chars_format __rhs) noexcept
662 { return (chars_format)((unsigned)__lhs & (unsigned)__rhs); }
664 constexpr chars_format
665 operator^(chars_format __lhs, chars_format __rhs) noexcept
666 { return (chars_format)((unsigned)__lhs ^ (unsigned)__rhs); }
668 constexpr chars_format
669 operator~(chars_format __fmt) noexcept
670 { return (chars_format)~(unsigned)__fmt; }
672 constexpr chars_format&
673 operator|=(chars_format& __lhs, chars_format __rhs) noexcept
674 { return __lhs = __lhs | __rhs; }
676 constexpr chars_format&
677 operator&=(chars_format& __lhs, chars_format __rhs) noexcept
678 { return __lhs = __lhs & __rhs; }
680 constexpr chars_format&
681 operator^=(chars_format& __lhs, chars_format __rhs) noexcept
682 { return __lhs = __lhs ^ __rhs; }
684 _GLIBCXX_END_NAMESPACE_VERSION
687 #endif // _GLIBCXX_CHARCONV