source: Daodan/MSYS2/mingw32/include/c++/11.2.0/charconv@ 1170

Last change on this file since 1170 was 1166, checked in by rossy, 3 years ago

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