| // Primitive numeric conversions (to_chars and from_chars) -*- C++ -*- |
| |
| // Copyright (C) 2017-2019 Free Software Foundation, Inc. |
| // |
| // This file is part of the GNU ISO C++ Library. This library is free |
| // software; you can redistribute it and/or modify it under the |
| // terms of the GNU General Public License as published by the |
| // Free Software Foundation; either version 3, or (at your option) |
| // any later version. |
| |
| // This library is distributed in the hope that it will be useful, |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| // GNU General Public License for more details. |
| |
| // Under Section 7 of GPL version 3, you are granted additional |
| // permissions described in the GCC Runtime Library Exception, version |
| // 3.1, as published by the Free Software Foundation. |
| |
| // You should have received a copy of the GNU General Public License and |
| // a copy of the GCC Runtime Library Exception along with this program; |
| // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
| // <http://www.gnu.org/licenses/>. |
| |
| /** @file include/charconv |
| * This is a Standard C++ Library header. |
| */ |
| |
| #ifndef _GLIBCXX_CHARCONV |
| #define _GLIBCXX_CHARCONV 1 |
| |
| #pragma GCC system_header |
| |
| #if __cplusplus >= 201402L |
| |
| #include <type_traits> |
| #include <limits> |
| #include <cctype> |
| #include <bits/charconv.h> // for __to_chars_len, __to_chars_10_impl |
| #include <bits/error_constants.h> // for std::errc |
| |
| // Define when floating point is supported: #define __cpp_lib_to_chars 201611L |
| |
| namespace std _GLIBCXX_VISIBILITY(default) |
| { |
| _GLIBCXX_BEGIN_NAMESPACE_VERSION |
| |
| /// Result type of std::to_chars |
| struct to_chars_result |
| { |
| char* ptr; |
| errc ec; |
| }; |
| |
| /// Result type of std::from_chars |
| struct from_chars_result |
| { |
| const char* ptr; |
| errc ec; |
| }; |
| |
| namespace __detail |
| { |
| template<typename _Tp> |
| using __integer_to_chars_result_type |
| = enable_if_t<__or_v<__is_signed_integer<_Tp>, |
| __is_unsigned_integer<_Tp>, |
| is_same<char, remove_cv_t<_Tp>>>, |
| to_chars_result>; |
| |
| // Pick an unsigned type of suitable size. This is used to reduce the |
| // number of specializations of __to_chars_len, __to_chars etc. that |
| // get instantiated. For example, to_chars<char> and to_chars<short> |
| // and to_chars<unsigned> will all use the same code, and so will |
| // to_chars<long> when sizeof(int) == sizeof(long). |
| template<typename _Tp> |
| struct __to_chars_unsigned_type : __make_unsigned_selector_base |
| { |
| using _UInts = _List<unsigned int, unsigned long, unsigned long long |
| #if _GLIBCXX_USE_INT128 |
| , unsigned __int128 |
| #endif |
| >; |
| using type = typename __select<sizeof(_Tp), _UInts>::__type; |
| }; |
| |
| template<typename _Tp> |
| using __unsigned_least_t = typename __to_chars_unsigned_type<_Tp>::type; |
| |
| // Generic implementation for arbitrary bases. |
| // Defined in <bits/charconv.h>. |
| template<typename _Tp> |
| constexpr unsigned |
| __to_chars_len(_Tp __value, int __base /* = 10 */) noexcept; |
| |
| template<typename _Tp> |
| constexpr unsigned |
| __to_chars_len_2(_Tp __value) noexcept |
| { |
| static_assert(is_integral<_Tp>::value, "implementation bug"); |
| static_assert(is_unsigned<_Tp>::value, "implementation bug"); |
| |
| constexpr size_t __nbits = __CHAR_BIT__ * sizeof(_Tp); |
| |
| // N.B. __builtin_clzll is undefined if __value == 0, but std::to_chars |
| // handles zero values directly. |
| |
| // For sizeof(_Tp) > 1 this is an order of magnitude faster than |
| // the generic __to_chars_len. |
| return __nbits |
| - (__builtin_clzll(__value) |
| - ((__CHAR_BIT__ * sizeof(long long)) - __nbits)); |
| } |
| |
| template<typename _Tp> |
| constexpr unsigned |
| __to_chars_len_8(_Tp __value) noexcept |
| { |
| static_assert(is_integral<_Tp>::value, "implementation bug"); |
| static_assert(is_unsigned<_Tp>::value, "implementation bug"); |
| |
| constexpr size_t __nbits = __CHAR_BIT__ * sizeof(_Tp); |
| |
| if _GLIBCXX17_CONSTEXPR (__nbits <= 16) |
| { |
| return __value > 077777u ? 6u |
| : __value > 07777u ? 5u |
| : __value > 0777u ? 4u |
| : __value > 077u ? 3u |
| : __value > 07u ? 2u |
| : 1u; |
| } |
| else |
| return __to_chars_len(__value, 8); |
| } |
| |
| // Generic implementation for arbitrary bases. |
| template<typename _Tp> |
| to_chars_result |
| __to_chars(char* __first, char* __last, _Tp __val, int __base) noexcept |
| { |
| static_assert(is_integral<_Tp>::value, "implementation bug"); |
| static_assert(is_unsigned<_Tp>::value, "implementation bug"); |
| |
| to_chars_result __res; |
| |
| const unsigned __len = __to_chars_len(__val, __base); |
| |
| if (__builtin_expect((__last - __first) < __len, 0)) |
| { |
| __res.ptr = __last; |
| __res.ec = errc::value_too_large; |
| return __res; |
| } |
| |
| unsigned __pos = __len - 1; |
| |
| static constexpr char __digits[] |
| = "0123456789abcdefghijklmnopqrstuvwxyz"; |
| |
| while (__val >= __base) |
| { |
| auto const __quo = __val / __base; |
| auto const __rem = __val % __base; |
| __first[__pos--] = __digits[__rem]; |
| __val = __quo; |
| } |
| *__first = __digits[__val]; |
| |
| __res.ptr = __first + __len; |
| __res.ec = {}; |
| return __res; |
| } |
| |
| template<typename _Tp> |
| __integer_to_chars_result_type<_Tp> |
| __to_chars_16(char* __first, char* __last, _Tp __val) noexcept |
| { |
| static_assert(is_integral<_Tp>::value, "implementation bug"); |
| static_assert(is_unsigned<_Tp>::value, "implementation bug"); |
| |
| to_chars_result __res; |
| |
| const unsigned __len = __to_chars_len(__val, 0x10); |
| |
| if (__builtin_expect((__last - __first) < __len, 0)) |
| { |
| __res.ptr = __last; |
| __res.ec = errc::value_too_large; |
| return __res; |
| } |
| |
| static constexpr char __digits[513] = |
| "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f" |
| "202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f" |
| "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f" |
| "606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f" |
| "808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f" |
| "a0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf" |
| "c0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf" |
| "e0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"; |
| unsigned __pos = __len - 1; |
| while (__val >= 0x100) |
| { |
| auto const __num = (__val % 0x100) * 2; |
| __val /= 0x100; |
| __first[__pos] = __digits[__num + 1]; |
| __first[__pos - 1] = __digits[__num]; |
| __pos -= 2; |
| } |
| if (__val >= 0x10) |
| { |
| auto const __num = __val * 2; |
| __first[__pos] = __digits[__num + 1]; |
| __first[__pos - 1] = __digits[__num]; |
| } |
| else |
| __first[__pos] = "0123456789abcdef"[__val]; |
| __res.ptr = __first + __len; |
| __res.ec = {}; |
| return __res; |
| } |
| |
| template<typename _Tp> |
| inline __integer_to_chars_result_type<_Tp> |
| __to_chars_10(char* __first, char* __last, _Tp __val) noexcept |
| { |
| static_assert(is_integral<_Tp>::value, "implementation bug"); |
| static_assert(is_unsigned<_Tp>::value, "implementation bug"); |
| |
| to_chars_result __res; |
| |
| const unsigned __len = __to_chars_len(__val, 10); |
| |
| if (__builtin_expect((__last - __first) < __len, 0)) |
| { |
| __res.ptr = __last; |
| __res.ec = errc::value_too_large; |
| return __res; |
| } |
| |
| __detail::__to_chars_10_impl(__first, __len, __val); |
| __res.ptr = __first + __len; |
| __res.ec = {}; |
| return __res; |
| } |
| |
| template<typename _Tp> |
| __integer_to_chars_result_type<_Tp> |
| __to_chars_8(char* __first, char* __last, _Tp __val) noexcept |
| { |
| static_assert(is_integral<_Tp>::value, "implementation bug"); |
| static_assert(is_unsigned<_Tp>::value, "implementation bug"); |
| |
| to_chars_result __res; |
| |
| const unsigned __len = __to_chars_len_8(__val); |
| |
| if (__builtin_expect((__last - __first) < __len, 0)) |
| { |
| __res.ptr = __last; |
| __res.ec = errc::value_too_large; |
| return __res; |
| } |
| |
| static constexpr char __digits[129] = |
| "00010203040506071011121314151617" |
| "20212223242526273031323334353637" |
| "40414243444546475051525354555657" |
| "60616263646566677071727374757677"; |
| unsigned __pos = __len - 1; |
| while (__val >= 0100) |
| { |
| auto const __num = (__val % 0100) * 2; |
| __val /= 0100; |
| __first[__pos] = __digits[__num + 1]; |
| __first[__pos - 1] = __digits[__num]; |
| __pos -= 2; |
| } |
| if (__val >= 010) |
| { |
| auto const __num = __val * 2; |
| __first[__pos] = __digits[__num + 1]; |
| __first[__pos - 1] = __digits[__num]; |
| } |
| else |
| __first[__pos] = '0' + __val; |
| __res.ptr = __first + __len; |
| __res.ec = {}; |
| return __res; |
| } |
| |
| template<typename _Tp> |
| __integer_to_chars_result_type<_Tp> |
| __to_chars_2(char* __first, char* __last, _Tp __val) noexcept |
| { |
| static_assert(is_integral<_Tp>::value, "implementation bug"); |
| static_assert(is_unsigned<_Tp>::value, "implementation bug"); |
| |
| to_chars_result __res; |
| |
| const unsigned __len = __to_chars_len_2(__val); |
| |
| if (__builtin_expect((__last - __first) < __len, 0)) |
| { |
| __res.ptr = __last; |
| __res.ec = errc::value_too_large; |
| return __res; |
| } |
| |
| unsigned __pos = __len - 1; |
| |
| while (__pos) |
| { |
| __first[__pos--] = '0' + (__val & 1); |
| __val >>= 1; |
| } |
| *__first = '0' + (__val & 1); |
| |
| __res.ptr = __first + __len; |
| __res.ec = {}; |
| return __res; |
| } |
| |
| } // namespace __detail |
| |
| template<typename _Tp> |
| __detail::__integer_to_chars_result_type<_Tp> |
| to_chars(char* __first, char* __last, _Tp __value, int __base = 10) |
| { |
| __glibcxx_assert(2 <= __base && __base <= 36); |
| |
| using _Up = __detail::__unsigned_least_t<_Tp>; |
| _Up __unsigned_val = __value; |
| |
| if (__value == 0 && __first != __last) |
| { |
| *__first = '0'; |
| return { __first + 1, errc{} }; |
| } |
| |
| if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value) |
| if (__value < 0) |
| { |
| if (__builtin_expect(__first != __last, 1)) |
| *__first++ = '-'; |
| __unsigned_val = _Up(~__value) + _Up(1); |
| } |
| |
| switch (__base) |
| { |
| case 16: |
| return __detail::__to_chars_16(__first, __last, __unsigned_val); |
| case 10: |
| return __detail::__to_chars_10(__first, __last, __unsigned_val); |
| case 8: |
| return __detail::__to_chars_8(__first, __last, __unsigned_val); |
| case 2: |
| return __detail::__to_chars_2(__first, __last, __unsigned_val); |
| default: |
| return __detail::__to_chars(__first, __last, __unsigned_val, __base); |
| } |
| } |
| |
| namespace __detail |
| { |
| template<typename _Tp> |
| bool |
| __raise_and_add(_Tp& __val, int __base, unsigned char __c) |
| { |
| if (__builtin_mul_overflow(__val, __base, &__val) |
| || __builtin_add_overflow(__val, __c, &__val)) |
| return false; |
| return true; |
| } |
| |
| /// std::from_chars implementation for integers in base 2. |
| template<typename _Tp> |
| bool |
| __from_chars_binary(const char*& __first, const char* __last, _Tp& __val) |
| { |
| static_assert(is_integral<_Tp>::value, "implementation bug"); |
| static_assert(is_unsigned<_Tp>::value, "implementation bug"); |
| |
| const ptrdiff_t __len = __last - __first; |
| int __i = 0; |
| while (__i < __len) |
| { |
| const unsigned char __c = (unsigned)__first[__i] - '0'; |
| if (__c < 2) |
| __val = (__val << 1) | __c; |
| else |
| break; |
| __i++; |
| } |
| __first += __i; |
| return __i <= (sizeof(_Tp) * __CHAR_BIT__); |
| } |
| |
| /// std::from_chars implementation for integers in bases 3 to 10. |
| template<typename _Tp> |
| bool |
| __from_chars_digit(const char*& __first, const char* __last, _Tp& __val, |
| int __base) |
| { |
| static_assert(is_integral<_Tp>::value, "implementation bug"); |
| static_assert(is_unsigned<_Tp>::value, "implementation bug"); |
| |
| auto __matches = [__base](char __c) { |
| return '0' <= __c && __c <= ('0' + (__base - 1)); |
| }; |
| |
| while (__first != __last) |
| { |
| const char __c = *__first; |
| if (__matches(__c)) |
| { |
| if (!__raise_and_add(__val, __base, __c - '0')) |
| { |
| while (++__first != __last && __matches(*__first)) |
| ; |
| return false; |
| } |
| __first++; |
| } |
| else |
| return true; |
| } |
| return true; |
| } |
| |
| constexpr unsigned char |
| __from_chars_alpha_to_num(char __c) |
| { |
| switch (__c) |
| { |
| case 'a': |
| case 'A': |
| return 10; |
| case 'b': |
| case 'B': |
| return 11; |
| case 'c': |
| case 'C': |
| return 12; |
| case 'd': |
| case 'D': |
| return 13; |
| case 'e': |
| case 'E': |
| return 14; |
| case 'f': |
| case 'F': |
| return 15; |
| case 'g': |
| case 'G': |
| return 16; |
| case 'h': |
| case 'H': |
| return 17; |
| case 'i': |
| case 'I': |
| return 18; |
| case 'j': |
| case 'J': |
| return 19; |
| case 'k': |
| case 'K': |
| return 20; |
| case 'l': |
| case 'L': |
| return 21; |
| case 'm': |
| case 'M': |
| return 22; |
| case 'n': |
| case 'N': |
| return 23; |
| case 'o': |
| case 'O': |
| return 24; |
| case 'p': |
| case 'P': |
| return 25; |
| case 'q': |
| case 'Q': |
| return 26; |
| case 'r': |
| case 'R': |
| return 27; |
| case 's': |
| case 'S': |
| return 28; |
| case 't': |
| case 'T': |
| return 29; |
| case 'u': |
| case 'U': |
| return 30; |
| case 'v': |
| case 'V': |
| return 31; |
| case 'w': |
| case 'W': |
| return 32; |
| case 'x': |
| case 'X': |
| return 33; |
| case 'y': |
| case 'Y': |
| return 34; |
| case 'z': |
| case 'Z': |
| return 35; |
| } |
| return std::numeric_limits<unsigned char>::max(); |
| } |
| |
| /// std::from_chars implementation for integers in bases 11 to 26. |
| template<typename _Tp> |
| bool |
| __from_chars_alnum(const char*& __first, const char* __last, _Tp& __val, |
| int __base) |
| { |
| bool __valid = true; |
| while (__first != __last) |
| { |
| unsigned char __c = *__first; |
| if (std::isdigit(__c)) |
| __c -= '0'; |
| else |
| { |
| __c = __from_chars_alpha_to_num(__c); |
| if (__c >= __base) |
| break; |
| } |
| |
| if (__builtin_expect(__valid, 1)) |
| __valid = __raise_and_add(__val, __base, __c); |
| __first++; |
| } |
| return __valid; |
| } |
| |
| template<typename _Tp> |
| using __integer_from_chars_result_type |
| = enable_if_t<__or_v<__is_signed_integer<_Tp>, |
| __is_unsigned_integer<_Tp>, |
| is_same<char, remove_cv_t<_Tp>>>, |
| from_chars_result>; |
| |
| } // namespace __detail |
| |
| /// std::from_chars for integral types. |
| template<typename _Tp> |
| __detail::__integer_from_chars_result_type<_Tp> |
| from_chars(const char* __first, const char* __last, _Tp& __value, |
| int __base = 10) |
| { |
| __glibcxx_assert(2 <= __base && __base <= 36); |
| |
| from_chars_result __res{__first, {}}; |
| |
| int __sign = 1; |
| if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value) |
| if (__first != __last && *__first == '-') |
| { |
| __sign = -1; |
| ++__first; |
| } |
| |
| using _Up = __detail::__unsigned_least_t<_Tp>; |
| _Up __val = 0; |
| |
| const auto __start = __first; |
| bool __valid; |
| if (__base == 2) |
| __valid = __detail::__from_chars_binary(__first, __last, __val); |
| else if (__base <= 10) |
| __valid = __detail::__from_chars_digit(__first, __last, __val, __base); |
| else |
| __valid = __detail::__from_chars_alnum(__first, __last, __val, __base); |
| |
| if (__builtin_expect(__first == __start, 0)) |
| __res.ec = errc::invalid_argument; |
| else |
| { |
| __res.ptr = __first; |
| if (!__valid) |
| __res.ec = errc::result_out_of_range; |
| else |
| { |
| if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value) |
| { |
| _Tp __tmp; |
| if (__builtin_mul_overflow(__val, __sign, &__tmp)) |
| __res.ec = errc::result_out_of_range; |
| else |
| __value = __tmp; |
| } |
| else |
| { |
| if _GLIBCXX17_CONSTEXPR |
| (numeric_limits<_Up>::max() > numeric_limits<_Tp>::max()) |
| { |
| if (__val > numeric_limits<_Tp>::max()) |
| __res.ec = errc::result_out_of_range; |
| else |
| __value = __val; |
| } |
| else |
| __value = __val; |
| } |
| } |
| } |
| return __res; |
| } |
| |
| /// floating-point format for primitive numerical conversion |
| enum class chars_format |
| { |
| scientific = 1, fixed = 2, hex = 4, general = fixed | scientific |
| }; |
| |
| constexpr chars_format |
| operator|(chars_format __lhs, chars_format __rhs) noexcept |
| { return (chars_format)((unsigned)__lhs | (unsigned)__rhs); } |
| |
| constexpr chars_format |
| operator&(chars_format __lhs, chars_format __rhs) noexcept |
| { return (chars_format)((unsigned)__lhs & (unsigned)__rhs); } |
| |
| constexpr chars_format |
| operator^(chars_format __lhs, chars_format __rhs) noexcept |
| { return (chars_format)((unsigned)__lhs ^ (unsigned)__rhs); } |
| |
| constexpr chars_format |
| operator~(chars_format __fmt) noexcept |
| { return (chars_format)~(unsigned)__fmt; } |
| |
| constexpr chars_format& |
| operator|=(chars_format& __lhs, chars_format __rhs) noexcept |
| { return __lhs = __lhs | __rhs; } |
| |
| constexpr chars_format& |
| operator&=(chars_format& __lhs, chars_format __rhs) noexcept |
| { return __lhs = __lhs & __rhs; } |
| |
| constexpr chars_format& |
| operator^=(chars_format& __lhs, chars_format __rhs) noexcept |
| { return __lhs = __lhs ^ __rhs; } |
| |
| _GLIBCXX_END_NAMESPACE_VERSION |
| } // namespace std |
| #endif // C++14 |
| #endif // _GLIBCXX_CHARCONV |
