diff options
Diffstat (limited to 'thirdparty/ue-libcxx/include/c++/v1/charconv')
| -rw-r--r-- | thirdparty/ue-libcxx/include/c++/v1/charconv | 827 |
1 files changed, 0 insertions, 827 deletions
diff --git a/thirdparty/ue-libcxx/include/c++/v1/charconv b/thirdparty/ue-libcxx/include/c++/v1/charconv deleted file mode 100644 index 4f00755a8..000000000 --- a/thirdparty/ue-libcxx/include/c++/v1/charconv +++ /dev/null @@ -1,827 +0,0 @@ -// -*- C++ -*- -//===----------------------------------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_CHARCONV -#define _LIBCPP_CHARCONV - -/* - charconv synopsis - -namespace std { - - // floating-point format for primitive numerical conversion - enum class chars_format { - scientific = unspecified, - fixed = unspecified, - hex = unspecified, - general = fixed | scientific - }; - - // 23.20.2, primitive numerical output conversion - struct to_chars_result { - char* ptr; - errc ec; - friend bool operator==(const to_chars_result&, const to_chars_result&) = default; // since C++20 - }; - - to_chars_result to_chars(char* first, char* last, see below value, - int base = 10); - to_chars_result to_chars(char* first, char* last, bool value, - int base = 10) = delete; - - to_chars_result to_chars(char* first, char* last, float value); - to_chars_result to_chars(char* first, char* last, double value); - to_chars_result to_chars(char* first, char* last, long double value); - - to_chars_result to_chars(char* first, char* last, float value, - chars_format fmt); - to_chars_result to_chars(char* first, char* last, double value, - chars_format fmt); - to_chars_result to_chars(char* first, char* last, long double value, - chars_format fmt); - - to_chars_result to_chars(char* first, char* last, float value, - chars_format fmt, int precision); - to_chars_result to_chars(char* first, char* last, double value, - chars_format fmt, int precision); - to_chars_result to_chars(char* first, char* last, long double value, - chars_format fmt, int precision); - - // 23.20.3, primitive numerical input conversion - struct from_chars_result { - const char* ptr; - errc ec; - friend bool operator==(const from_chars_result&, const from_chars_result&) = default; // since C++20 - }; - - from_chars_result from_chars(const char* first, const char* last, - see below& value, int base = 10); - - from_chars_result from_chars(const char* first, const char* last, - float& value, - chars_format fmt = chars_format::general); - from_chars_result from_chars(const char* first, const char* last, - double& value, - chars_format fmt = chars_format::general); - from_chars_result from_chars(const char* first, const char* last, - long double& value, - chars_format fmt = chars_format::general); - -} // namespace std - -*/ - -#include <__assert> // all public C++ headers provide the assertion handler -#include <__availability> -#include <__bits> -#include <__charconv/chars_format.h> -#include <__charconv/from_chars_result.h> -#include <__charconv/tables.h> -#include <__charconv/to_chars_base_10.h> -#include <__charconv/to_chars_result.h> -#include <__config> -#include <__debug> -#include <__errc> -#include <__type_traits/make_32_64_or_128_bit.h> -#include <__utility/unreachable.h> -#include <cmath> // for log2f -#include <cstdint> -#include <cstdlib> -#include <cstring> -#include <limits> -#include <type_traits> - -#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES -# include <iosfwd> -#endif - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -# pragma GCC system_header -#endif - -_LIBCPP_PUSH_MACROS -#include <__undef_macros> - -_LIBCPP_BEGIN_NAMESPACE_STD - -#ifndef _LIBCPP_CXX03_LANG - -to_chars_result to_chars(char*, char*, bool, int = 10) = delete; -from_chars_result from_chars(const char*, const char*, bool, int = 10) = delete; - -namespace __itoa -{ - -template <typename _Tp, typename = void> -struct _LIBCPP_HIDDEN __traits_base; - -template <typename _Tp> -struct _LIBCPP_HIDDEN __traits_base<_Tp, __enable_if_t<sizeof(_Tp) <= sizeof(uint32_t)>> -{ - using type = uint32_t; - - /// The width estimation using a log10 algorithm. - /// - /// The algorithm is based on - /// http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10 - /// Instead of using IntegerLogBase2 it uses __libcpp_clz. Since that - /// function requires its input to have at least one bit set the value of - /// zero is set to one. This means the first element of the lookup table is - /// zero. - static _LIBCPP_HIDE_FROM_ABI int __width(_Tp __v) - { - auto __t = (32 - std::__libcpp_clz(static_cast<type>(__v | 1))) * 1233 >> 12; - return __t - (__v < __table<>::__pow10_32[__t]) + 1; - } - - static _LIBCPP_HIDE_FROM_ABI char* __convert(char* __p, _Tp __v) - { - return __itoa::__base_10_u32(__p, __v); - } - - static _LIBCPP_HIDE_FROM_ABI decltype(__table<>::__pow10_32)& __pow() { return __table<>::__pow10_32; } -}; - -template <typename _Tp> -struct _LIBCPP_HIDDEN - __traits_base<_Tp, __enable_if_t<sizeof(_Tp) == sizeof(uint64_t)>> { - using type = uint64_t; - - /// The width estimation using a log10 algorithm. - /// - /// The algorithm is based on - /// http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10 - /// Instead of using IntegerLogBase2 it uses __libcpp_clz. Since that - /// function requires its input to have at least one bit set the value of - /// zero is set to one. This means the first element of the lookup table is - /// zero. - static _LIBCPP_HIDE_FROM_ABI int __width(_Tp __v) { - auto __t = (64 - std::__libcpp_clz(static_cast<type>(__v | 1))) * 1233 >> 12; - return __t - (__v < __table<>::__pow10_64[__t]) + 1; - } - - static _LIBCPP_HIDE_FROM_ABI char* __convert(char* __p, _Tp __v) { return __itoa::__base_10_u64(__p, __v); } - - static _LIBCPP_HIDE_FROM_ABI decltype(__table<>::__pow10_64)& __pow() { return __table<>::__pow10_64; } -}; - - -# ifndef _LIBCPP_HAS_NO_INT128 -template <typename _Tp> -struct _LIBCPP_HIDDEN - __traits_base<_Tp, __enable_if_t<sizeof(_Tp) == sizeof(__uint128_t)> > { - using type = __uint128_t; - - /// The width estimation using a log10 algorithm. - /// - /// The algorithm is based on - /// http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10 - /// Instead of using IntegerLogBase2 it uses __libcpp_clz. Since that - /// function requires its input to have at least one bit set the value of - /// zero is set to one. This means the first element of the lookup table is - /// zero. - static _LIBCPP_HIDE_FROM_ABI int __width(_Tp __v) { - _LIBCPP_ASSERT(__v > numeric_limits<uint64_t>::max(), "The optimizations for this algorithm fail when this isn't true."); - // There's always a bit set in the upper 64-bits. - auto __t = (128 - std::__libcpp_clz(static_cast<uint64_t>(__v >> 64))) * 1233 >> 12; - _LIBCPP_ASSERT(__t >= __table<>::__pow10_128_offset, "Index out of bounds"); - // __t is adjusted since the lookup table misses the lower entries. - return __t - (__v < __table<>::__pow10_128[__t - __table<>::__pow10_128_offset]) + 1; - } - - static _LIBCPP_HIDE_FROM_ABI char* __convert(char* __p, _Tp __v) { return __itoa::__base_10_u128(__p, __v); } - - // TODO FMT This pow function should get an index. - // By moving this to its own header it can be reused by the pow function in to_chars_base_10. - static _LIBCPP_HIDE_FROM_ABI decltype(__table<>::__pow10_128)& __pow() { return __table<>::__pow10_128; } -}; -#endif - -template <typename _Tp> -inline _LIBCPP_HIDE_FROM_ABI bool -__mul_overflowed(unsigned char __a, _Tp __b, unsigned char& __r) -{ - auto __c = __a * __b; - __r = __c; - return __c > numeric_limits<unsigned char>::max(); -} - -template <typename _Tp> -inline _LIBCPP_HIDE_FROM_ABI bool -__mul_overflowed(unsigned short __a, _Tp __b, unsigned short& __r) -{ - auto __c = __a * __b; - __r = __c; - return __c > numeric_limits<unsigned short>::max(); -} - -template <typename _Tp> -inline _LIBCPP_HIDE_FROM_ABI bool -__mul_overflowed(_Tp __a, _Tp __b, _Tp& __r) -{ - static_assert(is_unsigned<_Tp>::value, ""); -#if !defined(_LIBCPP_COMPILER_MSVC) - return __builtin_mul_overflow(__a, __b, &__r); -#else - bool __did = __b && (numeric_limits<_Tp>::max() / __b) < __a; - __r = __a * __b; - return __did; -#endif -} - -template <typename _Tp, typename _Up> -inline _LIBCPP_HIDE_FROM_ABI bool -__mul_overflowed(_Tp __a, _Up __b, _Tp& __r) -{ - return __mul_overflowed(__a, static_cast<_Tp>(__b), __r); -} - -template <typename _Tp> -struct _LIBCPP_HIDDEN __traits : __traits_base<_Tp> -{ - static constexpr int digits = numeric_limits<_Tp>::digits10 + 1; - using __traits_base<_Tp>::__pow; - using typename __traits_base<_Tp>::type; - - // precondition: at least one non-zero character available - static _LIBCPP_HIDE_FROM_ABI char const* - __read(char const* __p, char const* __ep, type& __a, type& __b) - { - type __cprod[digits]; - int __j = digits - 1; - int __i = digits; - do - { - if (!('0' <= *__p && *__p <= '9')) - break; - __cprod[--__i] = *__p++ - '0'; - } while (__p != __ep && __i != 0); - - __a = __inner_product(__cprod + __i + 1, __cprod + __j, __pow() + 1, - __cprod[__i]); - if (__mul_overflowed(__cprod[__j], __pow()[__j - __i], __b)) - --__p; - return __p; - } - - template <typename _It1, typename _It2, class _Up> - static _LIBCPP_HIDE_FROM_ABI _Up - __inner_product(_It1 __first1, _It1 __last1, _It2 __first2, _Up __init) - { - for (; __first1 < __last1; ++__first1, ++__first2) - __init = __init + *__first1 * *__first2; - return __init; - } -}; - -} // namespace __itoa - -template <typename _Tp> -inline _LIBCPP_HIDE_FROM_ABI _Tp -__complement(_Tp __x) -{ - static_assert(is_unsigned<_Tp>::value, "cast to unsigned first"); - return _Tp(~__x + 1); -} - -template <typename _Tp> -inline _LIBCPP_HIDE_FROM_ABI to_chars_result -__to_chars_itoa(char* __first, char* __last, _Tp __value, true_type) -{ - auto __x = __to_unsigned_like(__value); - if (__value < 0 && __first != __last) - { - *__first++ = '-'; - __x = __complement(__x); - } - - return __to_chars_itoa(__first, __last, __x, false_type()); -} - -template <typename _Tp> -inline _LIBCPP_HIDE_FROM_ABI to_chars_result -__to_chars_itoa(char* __first, char* __last, _Tp __value, false_type) -{ - using __tx = __itoa::__traits<_Tp>; - auto __diff = __last - __first; - - if (__tx::digits <= __diff || __tx::__width(__value) <= __diff) - return {__tx::__convert(__first, __value), errc(0)}; - else - return {__last, errc::value_too_large}; -} - -# ifndef _LIBCPP_HAS_NO_INT128 -template <> -inline _LIBCPP_HIDE_FROM_ABI to_chars_result -__to_chars_itoa(char* __first, char* __last, __uint128_t __value, false_type) -{ - // When the value fits in 64-bits use the 64-bit code path. This reduces - // the number of expensive calculations on 128-bit values. - // - // NOTE the 128-bit code path requires this optimization. - if(__value <= numeric_limits<uint64_t>::max()) - return __to_chars_itoa(__first, __last, static_cast<uint64_t>(__value), false_type()); - - using __tx = __itoa::__traits<__uint128_t>; - auto __diff = __last - __first; - - if (__tx::digits <= __diff || __tx::__width(__value) <= __diff) - return {__tx::__convert(__first, __value), errc(0)}; - else - return {__last, errc::value_too_large}; -} -#endif - -template <typename _Tp> -inline _LIBCPP_HIDE_FROM_ABI to_chars_result -__to_chars_integral(char* __first, char* __last, _Tp __value, int __base, - true_type) -{ - auto __x = __to_unsigned_like(__value); - if (__value < 0 && __first != __last) - { - *__first++ = '-'; - __x = __complement(__x); - } - - return __to_chars_integral(__first, __last, __x, __base, false_type()); -} - -namespace __itoa { - -template <unsigned _Base> -struct _LIBCPP_HIDDEN __integral; - -template <> -struct _LIBCPP_HIDDEN __integral<2> { - template <typename _Tp> - _LIBCPP_HIDE_FROM_ABI static constexpr int __width(_Tp __value) noexcept { - // If value == 0 still need one digit. If the value != this has no - // effect since the code scans for the most significant bit set. (Note - // that __libcpp_clz doesn't work for 0.) - return numeric_limits<_Tp>::digits - std::__libcpp_clz(__value | 1); - } - - template <typename _Tp> - _LIBCPP_HIDE_FROM_ABI static to_chars_result __to_chars(char* __first, char* __last, _Tp __value) { - ptrdiff_t __cap = __last - __first; - int __n = __width(__value); - if (__n > __cap) - return {__last, errc::value_too_large}; - - __last = __first + __n; - char* __p = __last; - const unsigned __divisor = 16; - while (__value > __divisor) { - unsigned __c = __value % __divisor; - __value /= __divisor; - __p -= 4; - std::memcpy(__p, &__table<>::__base_2_lut[4 * __c], 4); - } - do { - unsigned __c = __value % 2; - __value /= 2; - *--__p = "01"[__c]; - } while (__value != 0); - return {__last, errc(0)}; - } -}; - -template <> -struct _LIBCPP_HIDDEN __integral<8> { - template <typename _Tp> - _LIBCPP_HIDE_FROM_ABI static constexpr int __width(_Tp __value) noexcept { - // If value == 0 still need one digit. If the value != this has no - // effect since the code scans for the most significat bit set. (Note - // that __libcpp_clz doesn't work for 0.) - return ((numeric_limits<_Tp>::digits - std::__libcpp_clz(__value | 1)) + 2) / 3; - } - - template <typename _Tp> - _LIBCPP_HIDE_FROM_ABI static to_chars_result __to_chars(char* __first, char* __last, _Tp __value) { - ptrdiff_t __cap = __last - __first; - int __n = __width(__value); - if (__n > __cap) - return {__last, errc::value_too_large}; - - __last = __first + __n; - char* __p = __last; - unsigned __divisor = 64; - while (__value > __divisor) { - unsigned __c = __value % __divisor; - __value /= __divisor; - __p -= 2; - std::memcpy(__p, &__table<>::__base_8_lut[2 * __c], 2); - } - do { - unsigned __c = __value % 8; - __value /= 8; - *--__p = "01234567"[__c]; - } while (__value != 0); - return {__last, errc(0)}; - } - -}; - -template <> -struct _LIBCPP_HIDDEN __integral<16> { - template <typename _Tp> - _LIBCPP_HIDE_FROM_ABI static constexpr int __width(_Tp __value) noexcept { - // If value == 0 still need one digit. If the value != this has no - // effect since the code scans for the most significat bit set. (Note - // that __libcpp_clz doesn't work for 0.) - return (numeric_limits<_Tp>::digits - std::__libcpp_clz(__value | 1) + 3) / 4; - } - - template <typename _Tp> - _LIBCPP_HIDE_FROM_ABI static to_chars_result __to_chars(char* __first, char* __last, _Tp __value) { - ptrdiff_t __cap = __last - __first; - int __n = __width(__value); - if (__n > __cap) - return {__last, errc::value_too_large}; - - __last = __first + __n; - char* __p = __last; - unsigned __divisor = 256; - while (__value > __divisor) { - unsigned __c = __value % __divisor; - __value /= __divisor; - __p -= 2; - std::memcpy(__p, &__table<>::__base_16_lut[2 * __c], 2); - } - if (__first != __last) - do { - unsigned __c = __value % 16; - __value /= 16; - *--__p = "0123456789abcdef"[__c]; - } while (__value != 0); - return {__last, errc(0)}; - } -}; - -} // namespace __itoa - -template <unsigned _Base, typename _Tp, - typename enable_if<(sizeof(_Tp) >= sizeof(unsigned)), int>::type = 0> -_LIBCPP_HIDE_FROM_ABI int -__to_chars_integral_width(_Tp __value) { - return __itoa::__integral<_Base>::__width(__value); -} - -template <unsigned _Base, typename _Tp, - typename enable_if<(sizeof(_Tp) < sizeof(unsigned)), int>::type = 0> -_LIBCPP_HIDE_FROM_ABI int -__to_chars_integral_width(_Tp __value) { - return std::__to_chars_integral_width<_Base>(static_cast<unsigned>(__value)); -} - -template <unsigned _Base, typename _Tp, - typename enable_if<(sizeof(_Tp) >= sizeof(unsigned)), int>::type = 0> -_LIBCPP_HIDE_FROM_ABI to_chars_result -__to_chars_integral(char* __first, char* __last, _Tp __value) { - return __itoa::__integral<_Base>::__to_chars(__first, __last, __value); -} - -template <unsigned _Base, typename _Tp, - typename enable_if<(sizeof(_Tp) < sizeof(unsigned)), int>::type = 0> -_LIBCPP_HIDE_FROM_ABI to_chars_result -__to_chars_integral(char* __first, char* __last, _Tp __value) { - return std::__to_chars_integral<_Base>(__first, __last, static_cast<unsigned>(__value)); -} - -template <typename _Tp> -_LIBCPP_HIDE_FROM_ABI int -__to_chars_integral_width(_Tp __value, unsigned __base) { - _LIBCPP_ASSERT(__value >= 0, "The function requires a non-negative value."); - - unsigned __base_2 = __base * __base; - unsigned __base_3 = __base_2 * __base; - unsigned __base_4 = __base_2 * __base_2; - - int __r = 0; - while (true) { - if (__value < __base) - return __r + 1; - if (__value < __base_2) - return __r + 2; - if (__value < __base_3) - return __r + 3; - if (__value < __base_4) - return __r + 4; - - __value /= __base_4; - __r += 4; - } - - __libcpp_unreachable(); -} - -template <typename _Tp> -inline _LIBCPP_HIDE_FROM_ABI to_chars_result -__to_chars_integral(char* __first, char* __last, _Tp __value, int __base, - false_type) -{ - if (__base == 10) [[likely]] - return __to_chars_itoa(__first, __last, __value, false_type()); - - switch (__base) { - case 2: - return __to_chars_integral<2>(__first, __last, __value); - case 8: - return __to_chars_integral<8>(__first, __last, __value); - case 16: - return __to_chars_integral<16>(__first, __last, __value); - } - - ptrdiff_t __cap = __last - __first; - int __n = __to_chars_integral_width(__value, __base); - if (__n > __cap) - return {__last, errc::value_too_large}; - - __last = __first + __n; - char* __p = __last; - do { - unsigned __c = __value % __base; - __value /= __base; - *--__p = "0123456789abcdefghijklmnopqrstuvwxyz"[__c]; - } while (__value != 0); - return {__last, errc(0)}; -} - -template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0> -inline _LIBCPP_HIDE_FROM_ABI to_chars_result -to_chars(char* __first, char* __last, _Tp __value) -{ - using _Type = __make_32_64_or_128_bit_t<_Tp>; - static_assert(!is_same<_Type, void>::value, "unsupported integral type used in to_chars"); - return std::__to_chars_itoa(__first, __last, static_cast<_Type>(__value), is_signed<_Tp>()); -} - -template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0> -inline _LIBCPP_HIDE_FROM_ABI to_chars_result -to_chars(char* __first, char* __last, _Tp __value, int __base) -{ - _LIBCPP_ASSERT(2 <= __base && __base <= 36, "base not in [2, 36]"); - - using _Type = __make_32_64_or_128_bit_t<_Tp>; - return std::__to_chars_integral(__first, __last, static_cast<_Type>(__value), __base, is_signed<_Tp>()); -} - -template <typename _It, typename _Tp, typename _Fn, typename... _Ts> -inline _LIBCPP_HIDE_FROM_ABI from_chars_result -__sign_combinator(_It __first, _It __last, _Tp& __value, _Fn __f, _Ts... __args) -{ - using __tl = numeric_limits<_Tp>; - decltype(__to_unsigned_like(__value)) __x; - - bool __neg = (__first != __last && *__first == '-'); - auto __r = __f(__neg ? __first + 1 : __first, __last, __x, __args...); - switch (__r.ec) - { - case errc::invalid_argument: - return {__first, __r.ec}; - case errc::result_out_of_range: - return __r; - default: - break; - } - - if (__neg) - { - if (__x <= __complement(__to_unsigned_like(__tl::min()))) - { - __x = __complement(__x); - std::memcpy(&__value, &__x, sizeof(__x)); - return __r; - } - } - else - { - if (__x <= __to_unsigned_like(__tl::max())) - { - __value = __x; - return __r; - } - } - - return {__r.ptr, errc::result_out_of_range}; -} - -template <typename _Tp> -inline _LIBCPP_HIDE_FROM_ABI bool -__in_pattern(_Tp __c) -{ - return '0' <= __c && __c <= '9'; -} - -struct _LIBCPP_HIDDEN __in_pattern_result -{ - bool __ok; - int __val; - - explicit _LIBCPP_HIDE_FROM_ABI operator bool() const { return __ok; } -}; - -template <typename _Tp> -inline _LIBCPP_HIDE_FROM_ABI __in_pattern_result -__in_pattern(_Tp __c, int __base) -{ - if (__base <= 10) - return {'0' <= __c && __c < '0' + __base, __c - '0'}; - else if (__in_pattern(__c)) - return {true, __c - '0'}; - else if ('a' <= __c && __c < 'a' + __base - 10) - return {true, __c - 'a' + 10}; - else - return {'A' <= __c && __c < 'A' + __base - 10, __c - 'A' + 10}; -} - -template <typename _It, typename _Tp, typename _Fn, typename... _Ts> -inline _LIBCPP_HIDE_FROM_ABI from_chars_result -__subject_seq_combinator(_It __first, _It __last, _Tp& __value, _Fn __f, - _Ts... __args) -{ - auto __find_non_zero = [](_It __firstit, _It __lastit) { - for (; __firstit != __lastit; ++__firstit) - if (*__firstit != '0') - break; - return __firstit; - }; - - auto __p = __find_non_zero(__first, __last); - if (__p == __last || !__in_pattern(*__p, __args...)) - { - if (__p == __first) - return {__first, errc::invalid_argument}; - else - { - __value = 0; - return {__p, {}}; - } - } - - auto __r = __f(__p, __last, __value, __args...); - if (__r.ec == errc::result_out_of_range) - { - for (; __r.ptr != __last; ++__r.ptr) - { - if (!__in_pattern(*__r.ptr, __args...)) - break; - } - } - - return __r; -} - -template <typename _Tp, typename enable_if<is_unsigned<_Tp>::value, int>::type = 0> -inline _LIBCPP_HIDE_FROM_ABI from_chars_result -__from_chars_atoi(const char* __first, const char* __last, _Tp& __value) -{ - using __tx = __itoa::__traits<_Tp>; - using __output_type = typename __tx::type; - - return __subject_seq_combinator( - __first, __last, __value, - [](const char* __f, const char* __l, - _Tp& __val) -> from_chars_result { - __output_type __a, __b; - auto __p = __tx::__read(__f, __l, __a, __b); - if (__p == __l || !__in_pattern(*__p)) - { - __output_type __m = numeric_limits<_Tp>::max(); - if (__m >= __a && __m - __a >= __b) - { - __val = __a + __b; - return {__p, {}}; - } - } - return {__p, errc::result_out_of_range}; - }); -} - -template <typename _Tp, typename enable_if<is_signed<_Tp>::value, int>::type = 0> -inline _LIBCPP_HIDE_FROM_ABI from_chars_result -__from_chars_atoi(const char* __first, const char* __last, _Tp& __value) -{ - using __t = decltype(__to_unsigned_like(__value)); - return __sign_combinator(__first, __last, __value, __from_chars_atoi<__t>); -} - -template <typename _Tp, typename enable_if<is_unsigned<_Tp>::value, int>::type = 0> -inline _LIBCPP_HIDE_FROM_ABI from_chars_result -__from_chars_integral(const char* __first, const char* __last, _Tp& __value, - int __base) -{ - if (__base == 10) - return __from_chars_atoi(__first, __last, __value); - - return __subject_seq_combinator( - __first, __last, __value, - [](const char* __p, const char* __lastp, _Tp& __val, - int __b) -> from_chars_result { - using __tl = numeric_limits<_Tp>; - auto __digits = __tl::digits / log2f(float(__b)); - _Tp __x = __in_pattern(*__p++, __b).__val, __y = 0; - - for (int __i = 1; __p != __lastp; ++__i, ++__p) - { - if (auto __c = __in_pattern(*__p, __b)) - { - if (__i < __digits - 1) - __x = __x * __b + __c.__val; - else - { - if (!__itoa::__mul_overflowed(__x, __b, __x)) - ++__p; - __y = __c.__val; - break; - } - } - else - break; - } - - if (__p == __lastp || !__in_pattern(*__p, __b)) - { - if (__tl::max() - __x >= __y) - { - __val = __x + __y; - return {__p, {}}; - } - } - return {__p, errc::result_out_of_range}; - }, - __base); -} - -template <typename _Tp, typename enable_if<is_signed<_Tp>::value, int>::type = 0> -inline _LIBCPP_HIDE_FROM_ABI from_chars_result -__from_chars_integral(const char* __first, const char* __last, _Tp& __value, - int __base) -{ - using __t = decltype(__to_unsigned_like(__value)); - return __sign_combinator(__first, __last, __value, - __from_chars_integral<__t>, __base); -} - -template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0> -inline _LIBCPP_HIDE_FROM_ABI from_chars_result -from_chars(const char* __first, const char* __last, _Tp& __value) -{ - return __from_chars_atoi(__first, __last, __value); -} - -template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0> -inline _LIBCPP_HIDE_FROM_ABI from_chars_result -from_chars(const char* __first, const char* __last, _Tp& __value, int __base) -{ - _LIBCPP_ASSERT(2 <= __base && __base <= 36, "base not in [2, 36]"); - return __from_chars_integral(__first, __last, __value, __base); -} - -// Floating-point implementation starts here. -// Unlike the other parts of charconv this is only available in C++17 and newer. -#if _LIBCPP_STD_VER > 14 - -_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS -to_chars_result to_chars(char* __first, char* __last, float __value); - -_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS -to_chars_result to_chars(char* __first, char* __last, double __value); - -_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS -to_chars_result to_chars(char* __first, char* __last, long double __value); - -_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS -to_chars_result to_chars(char* __first, char* __last, float __value, chars_format __fmt); - -_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS -to_chars_result to_chars(char* __first, char* __last, double __value, chars_format __fmt); - -_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS -to_chars_result to_chars(char* __first, char* __last, long double __value, chars_format __fmt); - -_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS -to_chars_result to_chars(char* __first, char* __last, float __value, chars_format __fmt, int __precision); - -_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS -to_chars_result to_chars(char* __first, char* __last, double __value, chars_format __fmt, int __precision); - -_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS -to_chars_result to_chars(char* __first, char* __last, long double __value, chars_format __fmt, int __precision); - -# endif // _LIBCPP_STD_VER > 14 -#endif // _LIBCPP_CXX03_LANG - -_LIBCPP_END_NAMESPACE_STD - -_LIBCPP_POP_MACROS - -#endif // _LIBCPP_CHARCONV |