1// Primitive numeric conversions (to_chars and from_chars) -*- C++ -*-
2
3// Copyright (C) 2017-2021 Free Software Foundation, Inc.
4//
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)
9// any later version.
10
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.
15
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.
19
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/>.
24
25/** @file include/charconv
26 * This is a Standard C++ Library header.
27 */
28
29#ifndef _GLIBCXX_CHARCONV
30#define _GLIBCXX_CHARCONV 1
31
32#pragma GCC system_header
33
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
39
40#include <type_traits>
41#include <bit> // for __bit_width
42#include <bits/charconv.h> // for __to_chars_len, __to_chars_10_impl
43#include <bits/error_constants.h> // for std::errc
44#include <ext/numeric_traits.h>
45
46#if _GLIBCXX_HAVE_USELOCALE
47# define __cpp_lib_to_chars 201611L
48#endif
49
50namespace std _GLIBCXX_VISIBILITY(default)
51{
52_GLIBCXX_BEGIN_NAMESPACE_VERSION
53
54 /// Result type of std::to_chars
55 struct to_chars_result
56 {
57 char* ptr;
58 errc ec;
59
60#if __cplusplus > 201703L && __cpp_impl_three_way_comparison >= 201907L
61 friend bool
62 operator==(const to_chars_result&, const to_chars_result&) = default;
63#endif
64 };
65
66 /// Result type of std::from_chars
67 struct from_chars_result
68 {
69 const char* ptr;
70 errc ec;
71
72#if __cplusplus > 201703L && __cpp_impl_three_way_comparison >= 201907L
73 friend bool
74 operator==(const from_chars_result&, const from_chars_result&) = default;
75#endif
76 };
77
78namespace __detail
79{
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,
85 to_chars_result>;
86
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
94 {
95 using _UInts = _List<unsigned int, unsigned long, unsigned long long
96#if _GLIBCXX_USE_INT128
97 , unsigned __int128
98#endif
99 >;
100 using type = typename __select<sizeof(_Tp), _UInts>::__type;
101 };
102
103 template<typename _Tp>
104 using __unsigned_least_t = typename __to_chars_unsigned_type<_Tp>::type;
105
106 // Generic implementation for arbitrary bases.
107 // Defined in <bits/charconv.h>.
108 template<typename _Tp>
109 constexpr unsigned
110 __to_chars_len(_Tp __value, int __base /* = 10 */) noexcept;
111
112 template<typename _Tp>
113 constexpr unsigned
114 __to_chars_len_2(_Tp __value) noexcept
115 { return std::__bit_width(__value); }
116
117 // Generic implementation for arbitrary bases.
118 template<typename _Tp>
119 to_chars_result
120 __to_chars(char* __first, char* __last, _Tp __val, int __base) noexcept
121 {
122 static_assert(is_integral<_Tp>::value, "implementation bug");
123 static_assert(is_unsigned<_Tp>::value, "implementation bug");
124
125 to_chars_result __res;
126
127 const unsigned __len = __to_chars_len(__val, __base);
128
129 if (__builtin_expect((__last - __first) < __len, 0))
130 {
131 __res.ptr = __last;
132 __res.ec = errc::value_too_large;
133 return __res;
134 }
135
136 unsigned __pos = __len - 1;
137
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'
143 };
144
145 while (__val >= (unsigned)__base)
146 {
147 auto const __quo = __val / __base;
148 auto const __rem = __val % __base;
149 __first[__pos--] = __digits[__rem];
150 __val = __quo;
151 }
152 *__first = __digits[__val];
153
154 __res.ptr = __first + __len;
155 __res.ec = {};
156 return __res;
157 }
158
159 template<typename _Tp>
160 __integer_to_chars_result_type<_Tp>
161 __to_chars_16(char* __first, char* __last, _Tp __val) noexcept
162 {
163 static_assert(is_integral<_Tp>::value, "implementation bug");
164 static_assert(is_unsigned<_Tp>::value, "implementation bug");
165
166 to_chars_result __res;
167
168 const unsigned __len = (__to_chars_len_2(__val) + 3) / 4;
169
170 if (__builtin_expect((__last - __first) < __len, 0))
171 {
172 __res.ptr = __last;
173 __res.ec = errc::value_too_large;
174 return __res;
175 }
176
177 static constexpr char __digits[] = {
178 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
179 'a', 'b', 'c', 'd', 'e', 'f'
180 };
181 unsigned __pos = __len - 1;
182 while (__val >= 0x100)
183 {
184 auto __num = __val & 0xF;
185 __val >>= 4;
186 __first[__pos] = __digits[__num];
187 __num = __val & 0xF;
188 __val >>= 4;
189 __first[__pos - 1] = __digits[__num];
190 __pos -= 2;
191 }
192 if (__val >= 0x10)
193 {
194 const auto __num = __val & 0xF;
195 __val >>= 4;
196 __first[1] = __digits[__num];
197 __first[0] = __digits[__val];
198 }
199 else
200 __first[0] = __digits[__val];
201 __res.ptr = __first + __len;
202 __res.ec = {};
203 return __res;
204 }
205
206 template<typename _Tp>
207 inline __integer_to_chars_result_type<_Tp>
208 __to_chars_10(char* __first, char* __last, _Tp __val) noexcept
209 {
210 static_assert(is_integral<_Tp>::value, "implementation bug");
211 static_assert(is_unsigned<_Tp>::value, "implementation bug");
212
213 to_chars_result __res;
214
215 const unsigned __len = __to_chars_len(__val, 10);
216
217 if (__builtin_expect((__last - __first) < __len, 0))
218 {
219 __res.ptr = __last;
220 __res.ec = errc::value_too_large;
221 return __res;
222 }
223
224 __detail::__to_chars_10_impl(__first, __len, __val);
225 __res.ptr = __first + __len;
226 __res.ec = {};
227 return __res;
228 }
229
230 template<typename _Tp>
231 __integer_to_chars_result_type<_Tp>
232 __to_chars_8(char* __first, char* __last, _Tp __val) noexcept
233 {
234 static_assert(is_integral<_Tp>::value, "implementation bug");
235 static_assert(is_unsigned<_Tp>::value, "implementation bug");
236
237 to_chars_result __res;
238 unsigned __len;
239
240 if _GLIBCXX17_CONSTEXPR (__gnu_cxx::__int_traits<_Tp>::__digits <= 16)
241 {
242 __len = __val > 077777u ? 6u
243 : __val > 07777u ? 5u
244 : __val > 0777u ? 4u
245 : __val > 077u ? 3u
246 : __val > 07u ? 2u
247 : 1u;
248 }
249 else
250 __len = (__to_chars_len_2(__val) + 2) / 3;
251
252 if (__builtin_expect((__last - __first) < __len, 0))
253 {
254 __res.ptr = __last;
255 __res.ec = errc::value_too_large;
256 return __res;
257 }
258
259 unsigned __pos = __len - 1;
260 while (__val >= 0100)
261 {
262 auto __num = __val & 7;
263 __val >>= 3;
264 __first[__pos] = '0' + __num;
265 __num = __val & 7;
266 __val >>= 3;
267 __first[__pos - 1] = '0' + __num;
268 __pos -= 2;
269 }
270 if (__val >= 010)
271 {
272 auto const __num = __val & 7;
273 __val >>= 3;
274 __first[1] = '0' + __num;
275 __first[0] = '0' + __val;
276 }
277 else
278 __first[0] = '0' + __val;
279 __res.ptr = __first + __len;
280 __res.ec = {};
281 return __res;
282 }
283
284 template<typename _Tp>
285 __integer_to_chars_result_type<_Tp>
286 __to_chars_2(char* __first, char* __last, _Tp __val) noexcept
287 {
288 static_assert(is_integral<_Tp>::value, "implementation bug");
289 static_assert(is_unsigned<_Tp>::value, "implementation bug");
290
291 to_chars_result __res;
292
293 const unsigned __len = __to_chars_len_2(__val);
294
295 if (__builtin_expect((__last - __first) < __len, 0))
296 {
297 __res.ptr = __last;
298 __res.ec = errc::value_too_large;
299 return __res;
300 }
301
302 unsigned __pos = __len - 1;
303
304 while (__pos)
305 {
306 __first[__pos--] = '0' + (__val & 1);
307 __val >>= 1;
308 }
309 // First digit is always '1' because __to_chars_len_2 skips
310 // leading zero bits and std::to_chars handles zero values
311 // directly.
312 __first[0] = '1';
313
314 __res.ptr = __first + __len;
315 __res.ec = {};
316 return __res;
317 }
318
319} // namespace __detail
320
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)
324 {
325 __glibcxx_assert(2 <= __base && __base <= 36);
326
327 using _Up = __detail::__unsigned_least_t<_Tp>;
328 _Up __unsigned_val = __value;
329
330 if (__first == __last) [[__unlikely__]]
331 return { __last, errc::value_too_large };
332
333 if (__value == 0)
334 {
335 *__first = '0';
336 return { __first + 1, errc{} };
337 }
338 else if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
339 if (__value < 0)
340 {
341 *__first++ = '-';
342 __unsigned_val = _Up(~__value) + _Up(1);
343 }
344
345 switch (__base)
346 {
347 case 16:
348 return __detail::__to_chars_16(__first, __last, __unsigned_val);
349 case 10:
350 return __detail::__to_chars_10(__first, __last, __unsigned_val);
351 case 8:
352 return __detail::__to_chars_8(__first, __last, __unsigned_val);
353 case 2:
354 return __detail::__to_chars_2(__first, __last, __unsigned_val);
355 default:
356 return __detail::__to_chars(__first, __last, __unsigned_val, __base);
357 }
358 }
359
360#define _GLIBCXX_TO_CHARS(T) \
361 inline to_chars_result \
362 to_chars(char* __first, char* __last, T __value, int __base = 10) \
363 { return std::__to_chars_i<T>(__first, __last, __value, __base); }
364_GLIBCXX_TO_CHARS(char)
365_GLIBCXX_TO_CHARS(signed char)
366_GLIBCXX_TO_CHARS(unsigned char)
367_GLIBCXX_TO_CHARS(signed short)
368_GLIBCXX_TO_CHARS(unsigned short)
369_GLIBCXX_TO_CHARS(signed int)
370_GLIBCXX_TO_CHARS(unsigned int)
371_GLIBCXX_TO_CHARS(signed long)
372_GLIBCXX_TO_CHARS(unsigned long)
373_GLIBCXX_TO_CHARS(signed long long)
374_GLIBCXX_TO_CHARS(unsigned long long)
375#if defined(__GLIBCXX_TYPE_INT_N_0)
376_GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_0)
377_GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_0)
378#endif
379#if defined(__GLIBCXX_TYPE_INT_N_1)
380_GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_1)
381_GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_1)
382#endif
383#if defined(__GLIBCXX_TYPE_INT_N_2)
384_GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_2)
385_GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_2)
386#endif
387#if defined(__GLIBCXX_TYPE_INT_N_3)
388_GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_3)
389_GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_3)
390#endif
391#undef _GLIBCXX_TO_CHARS
392
393 // _GLIBCXX_RESOLVE_LIB_DEFECTS
394 // 3266. to_chars(bool) should be deleted
395 to_chars_result to_chars(char*, char*, bool, int = 10) = delete;
396
397namespace __detail
398{
399 template<typename _Tp>
400 bool
401 __raise_and_add(_Tp& __val, int __base, unsigned char __c)
402 {
403 if (__builtin_mul_overflow(__val, __base, &__val)
404 || __builtin_add_overflow(__val, __c, &__val))
405 return false;
406 return true;
407 }
408
409 /// std::from_chars implementation for integers in base 2.
410 template<typename _Tp>
411 bool
412 __from_chars_binary(const char*& __first, const char* __last, _Tp& __val)
413 {
414 static_assert(is_integral<_Tp>::value, "implementation bug");
415 static_assert(is_unsigned<_Tp>::value, "implementation bug");
416
417 const ptrdiff_t __len = __last - __first;
418 ptrdiff_t __i = 0;
419 while (__i < __len && __first[__i] == '0')
420 ++__i;
421 const ptrdiff_t __leading_zeroes = __i;
422
423 while (__i < __len)
424 {
425 const unsigned char __c = (unsigned)__first[__i] - '0';
426 if (__c < 2)
427 __val = (__val << 1) | __c;
428 else
429 break;
430 __i++;
431 }
432 __first += __i;
433 return (__i - __leading_zeroes) <= __gnu_cxx::__int_traits<_Tp>::__digits;
434 }
435
436 /// std::from_chars implementation for integers in bases 3 to 10.
437 template<typename _Tp>
438 bool
439 __from_chars_digit(const char*& __first, const char* __last, _Tp& __val,
440 int __base)
441 {
442 static_assert(is_integral<_Tp>::value, "implementation bug");
443 static_assert(is_unsigned<_Tp>::value, "implementation bug");
444
445 auto __matches = [__base](char __c) {
446 return '0' <= __c && __c <= ('0' + (__base - 1));
447 };
448
449 while (__first != __last)
450 {
451 const char __c = *__first;
452 if (__matches(__c))
453 {
454 if (!__raise_and_add(__val, __base, __c - '0'))
455 {
456 while (++__first != __last && __matches(*__first))
457 ;
458 return false;
459 }
460 __first++;
461 }
462 else
463 return true;
464 }
465 return true;
466 }
467
468 constexpr char
469 __from_chars_alpha_to_num(char __c)
470 {
471 switch (__c)
472 {
473 case 'a':
474 case 'A':
475 return 10;
476 case 'b':
477 case 'B':
478 return 11;
479 case 'c':
480 case 'C':
481 return 12;
482 case 'd':
483 case 'D':
484 return 13;
485 case 'e':
486 case 'E':
487 return 14;
488 case 'f':
489 case 'F':
490 return 15;
491 case 'g':
492 case 'G':
493 return 16;
494 case 'h':
495 case 'H':
496 return 17;
497 case 'i':
498 case 'I':
499 return 18;
500 case 'j':
501 case 'J':
502 return 19;
503 case 'k':
504 case 'K':
505 return 20;
506 case 'l':
507 case 'L':
508 return 21;
509 case 'm':
510 case 'M':
511 return 22;
512 case 'n':
513 case 'N':
514 return 23;
515 case 'o':
516 case 'O':
517 return 24;
518 case 'p':
519 case 'P':
520 return 25;
521 case 'q':
522 case 'Q':
523 return 26;
524 case 'r':
525 case 'R':
526 return 27;
527 case 's':
528 case 'S':
529 return 28;
530 case 't':
531 case 'T':
532 return 29;
533 case 'u':
534 case 'U':
535 return 30;
536 case 'v':
537 case 'V':
538 return 31;
539 case 'w':
540 case 'W':
541 return 32;
542 case 'x':
543 case 'X':
544 return 33;
545 case 'y':
546 case 'Y':
547 return 34;
548 case 'z':
549 case 'Z':
550 return 35;
551 }
552 return 127;
553 }
554
555 /// std::from_chars implementation for integers in bases 11 to 36.
556 template<typename _Tp>
557 bool
558 __from_chars_alnum(const char*& __first, const char* __last, _Tp& __val,
559 int __base)
560 {
561 bool __valid = true;
562 while (__first != __last)
563 {
564 char __c = *__first;
565 if ('0' <= __c && __c <= '9') // isdigit
566 __c -= '0';
567 else
568 {
569 __c = __from_chars_alpha_to_num(__c);
570 if (__c >= __base)
571 break;
572 }
573
574 if (__builtin_expect(__valid, 1))
575 __valid = __raise_and_add(__val, __base, __c);
576 __first++;
577 }
578 return __valid;
579 }
580
581 template<typename _Tp>
582 using __integer_from_chars_result_type
583 = enable_if_t<__or_<__is_signed_integer<_Tp>,
584 __is_unsigned_integer<_Tp>,
585 is_same<char, remove_cv_t<_Tp>>>::value,
586 from_chars_result>;
587
588} // namespace __detail
589
590 /// std::from_chars for integral types.
591 template<typename _Tp>
592 __detail::__integer_from_chars_result_type<_Tp>
593 from_chars(const char* __first, const char* __last, _Tp& __value,
594 int __base = 10)
595 {
596 __glibcxx_assert(2 <= __base && __base <= 36);
597
598 from_chars_result __res{.ptr: __first, .ec: {}};
599
600 int __sign = 1;
601 if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
602 if (__first != __last && *__first == '-')
603 {
604 __sign = -1;
605 ++__first;
606 }
607
608 using _Up = __detail::__unsigned_least_t<_Tp>;
609 _Up __val = 0;
610
611 const auto __start = __first;
612 bool __valid;
613 if (__base == 2)
614 __valid = __detail::__from_chars_binary(__first, __last, __val);
615 else if (__base <= 10)
616 __valid = __detail::__from_chars_digit(__first, __last, __val, __base);
617 else
618 __valid = __detail::__from_chars_alnum(__first, __last, __val, __base);
619
620 if (__builtin_expect(__first == __start, 0))
621 __res.ec = errc::invalid_argument;
622 else
623 {
624 __res.ptr = __first;
625 if (!__valid)
626 __res.ec = errc::result_out_of_range;
627 else
628 {
629 if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
630 {
631 _Tp __tmp;
632 if (__builtin_mul_overflow(__val, __sign, &__tmp))
633 __res.ec = errc::result_out_of_range;
634 else
635 __value = __tmp;
636 }
637 else
638 {
639 if _GLIBCXX17_CONSTEXPR (__gnu_cxx::__int_traits<_Up>::__max
640 > __gnu_cxx::__int_traits<_Tp>::__max)
641 {
642 if (__val > __gnu_cxx::__int_traits<_Tp>::__max)
643 __res.ec = errc::result_out_of_range;
644 else
645 __value = __val;
646 }
647 else
648 __value = __val;
649 }
650 }
651 }
652 return __res;
653 }
654
655 /// floating-point format for primitive numerical conversion
656 enum class chars_format
657 {
658 scientific = 1, fixed = 2, hex = 4, general = fixed | scientific
659 };
660
661 constexpr chars_format
662 operator|(chars_format __lhs, chars_format __rhs) noexcept
663 { return (chars_format)((unsigned)__lhs | (unsigned)__rhs); }
664
665 constexpr chars_format
666 operator&(chars_format __lhs, chars_format __rhs) noexcept
667 { return (chars_format)((unsigned)__lhs & (unsigned)__rhs); }
668
669 constexpr chars_format
670 operator^(chars_format __lhs, chars_format __rhs) noexcept
671 { return (chars_format)((unsigned)__lhs ^ (unsigned)__rhs); }
672
673 constexpr chars_format
674 operator~(chars_format __fmt) noexcept
675 { return (chars_format)~(unsigned)__fmt; }
676
677 constexpr chars_format&
678 operator|=(chars_format& __lhs, chars_format __rhs) noexcept
679 { return __lhs = __lhs | __rhs; }
680
681 constexpr chars_format&
682 operator&=(chars_format& __lhs, chars_format __rhs) noexcept
683 { return __lhs = __lhs & __rhs; }
684
685 constexpr chars_format&
686 operator^=(chars_format& __lhs, chars_format __rhs) noexcept
687 { return __lhs = __lhs ^ __rhs; }
688
689#if _GLIBCXX_HAVE_USELOCALE
690 from_chars_result
691 from_chars(const char* __first, const char* __last, float& __value,
692 chars_format __fmt = chars_format::general) noexcept;
693
694 from_chars_result
695 from_chars(const char* __first, const char* __last, double& __value,
696 chars_format __fmt = chars_format::general) noexcept;
697
698 from_chars_result
699 from_chars(const char* __first, const char* __last, long double& __value,
700 chars_format __fmt = chars_format::general) noexcept;
701#endif
702
703#if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 \
704 && __SIZE_WIDTH__ >= 32
705 // Floating-point std::to_chars
706
707 // Overloads for float.
708 to_chars_result to_chars(char* __first, char* __last, float __value) noexcept;
709 to_chars_result to_chars(char* __first, char* __last, float __value,
710 chars_format __fmt) noexcept;
711 to_chars_result to_chars(char* __first, char* __last, float __value,
712 chars_format __fmt, int __precision) noexcept;
713
714 // Overloads for double.
715 to_chars_result to_chars(char* __first, char* __last, double __value) noexcept;
716 to_chars_result to_chars(char* __first, char* __last, double __value,
717 chars_format __fmt) noexcept;
718 to_chars_result to_chars(char* __first, char* __last, double __value,
719 chars_format __fmt, int __precision) noexcept;
720
721 // Overloads for long double.
722 to_chars_result to_chars(char* __first, char* __last, long double __value)
723 noexcept;
724 to_chars_result to_chars(char* __first, char* __last, long double __value,
725 chars_format __fmt) noexcept;
726 to_chars_result to_chars(char* __first, char* __last, long double __value,
727 chars_format __fmt, int __precision) noexcept;
728#endif
729
730_GLIBCXX_END_NAMESPACE_VERSION
731} // namespace std
732#endif // C++14
733#endif // _GLIBCXX_CHARCONV
734

source code of include/c++/11/charconv