libcxx/include/__charconv/from_chars_integral.h

   1 // -*- C++ -*-
   2 //===----------------------------------------------------------------------===//
   3 //
   4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef _LIBCPP___CHARCONV_FROM_CHARS_INTEGRAL_H
  11 #define _LIBCPP___CHARCONV_FROM_CHARS_INTEGRAL_H
  12
  13 #include <__algorithm/copy_n.h>
  14 #include <__assert>
  15 #include <__charconv/from_chars_result.h>
  16 #include <__charconv/traits.h>
  17 #include <__config>
  18 #include <__memory/addressof.h>
  19 #include <__system_error/errc.h>
  20 #include <__type_traits/enable_if.h>
  21 #include <__type_traits/integral_constant.h>
  22 #include <__type_traits/is_integral.h>
  23 #include <__type_traits/is_unsigned.h>
  24 #include <__type_traits/make_unsigned.h>
  25 #include <limits>
  26
  27 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
  28 #  pragma GCC system_header
  29 #endif
  30
  31 _LIBCPP_PUSH_MACROS
  32 #include <__undef_macros>
  33
  34 _LIBCPP_BEGIN_NAMESPACE_STD
  35
  36 #if _LIBCPP_STD_VER >= 17
  37
  38 from_chars_result from_chars(const char*, const char*, bool, int = 10) = delete;
  39
  40 template <typename _It, typename _Tp, typename _Fn, typename... _Ts>
  41 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
  42 __sign_combinator(_It __first, _It __last, _Tp& __value, _Fn __f, _Ts... __args) {
  43   using __tl = numeric_limits<_Tp>;
  44   decltype(std::__to_unsigned_like(__value)) __x;
  45
  46   bool __neg = (__first != __last && *__first == '-');
  47   auto __r   = __f(__neg ? __first + 1 : __first, __last, __x, __args...);
  48   switch (__r.ec) {
  49   case errc::invalid_argument:
  50     return {__first, __r.ec};
  51   case errc::result_out_of_range:
  52     return __r;
  53   default:
  54     break;
  55   }
  56
  57   if (__neg) {
  58     if (__x <= std::__complement(std::__to_unsigned_like(__tl::min()))) {
  59       __x = std::__complement(__x);
  60       std::copy_n(std::addressof(__x), 1, std::addressof(__value));
  61       return __r;
  62     }
  63   } else {
  64     if (__x <= std::__to_unsigned_like(__tl::max())) {
  65       __value = __x;
  66       return __r;
  67     }
  68   }
  69
  70   return {__r.ptr, errc::result_out_of_range};
  71 }
  72
  73 template <typename _Tp>
  74 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool __in_pattern(_Tp __c) {
  75   return '0' <= __c && __c <= '9';
  76 }
  77
  78 struct _LIBCPP_HIDDEN __in_pattern_result {
  79   bool __ok;
  80   int __val;
  81
  82   explicit _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI operator bool() const { return __ok; }
  83 };
  84
  85 template <typename _Tp>
  86 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI __in_pattern_result __in_pattern(_Tp __c, int __base) {
  87   if (__base <= 10)
  88     return {'0' <= __c && __c < '0' + __base, __c - '0'};
  89   else if (std::__in_pattern(__c))
  90     return {true, __c - '0'};
  91   else if ('a' <= __c && __c < 'a' + __base - 10)
  92     return {true, __c - 'a' + 10};
  93   else
  94     return {'A' <= __c && __c < 'A' + __base - 10, __c - 'A' + 10};
  95 }
  96
  97 template <typename _It, typename _Tp, typename _Fn, typename... _Ts>
  98 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
  99 __subject_seq_combinator(_It __first, _It __last, _Tp& __value, _Fn __f, _Ts... __args) {
 100   auto __find_non_zero = [](_It __firstit, _It __lastit) {
 101     for (; __firstit != __lastit; ++__firstit)
 102       if (*__firstit != '0')
 103         break;
 104     return __firstit;
 105   };
 106
 107   auto __p = __find_non_zero(__first, __last);
 108   if (__p == __last || !std::__in_pattern(*__p, __args...)) {
 109     if (__p == __first)
 110       return {__first, errc::invalid_argument};
 111     else {
 112       __value = 0;
 113       return {__p, {}};
 114     }
 115   }
 116
 117   auto __r = __f(__p, __last, __value, __args...);
 118   if (__r.ec == errc::result_out_of_range) {
 119     for (; __r.ptr != __last; ++__r.ptr) {
 120       if (!std::__in_pattern(*__r.ptr, __args...))
 121         break;
 122     }
 123   }
 124
 125   return __r;
 126 }
 127
 128 template <typename _Tp, __enable_if_t<is_unsigned<_Tp>::value, int> = 0>
 129 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
 130 __from_chars_atoi(const char* __first, const char* __last, _Tp& __value) {
 131   using __tx          = __itoa::__traits<_Tp>;
 132   using __output_type = typename __tx::type;
 133
 134   return std::__subject_seq_combinator(
 135       __first, __last, __value, [](const char* __f, const char* __l, _Tp& __val) -> from_chars_result {
 136         __output_type __a, __b;
 137         auto __p = __tx::__read(__f, __l, __a, __b);
 138         if (__p == __l || !std::__in_pattern(*__p)) {
 139           __output_type __m = numeric_limits<_Tp>::max();
 140           if (__m >= __a && __m - __a >= __b) {
 141             __val = __a + __b;
 142             return {__p, {}};
 143           }
 144         }
 145         return {__p, errc::result_out_of_range};
 146       });
 147 }
 148
 149 template <typename _Tp, __enable_if_t<is_signed<_Tp>::value, int> = 0>
 150 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
 151 __from_chars_atoi(const char* __first, const char* __last, _Tp& __value) {
 152   using __t = decltype(std::__to_unsigned_like(__value));
 153   return std::__sign_combinator(__first, __last, __value, __from_chars_atoi<__t>);
 154 }
 155
 156 /*
 157 // Code used to generate __from_chars_log2f_lut.
 158 #include <cmath>
 159 #include <format>
 160 #include <iostream>
 161
 162 int main() {
 163   for (int i = 2; i <= 36; ++i)
 164     std::cout << std::format("{},\n", log2f(i));
 165 }
 166 */
 167 /// log2f table for bases [2, 36].
 168 inline constexpr float __from_chars_log2f_lut[35] = {
 169     1,         1.5849625, 2,         2.321928, 2.5849626, 2.807355, 3,        3.169925,  3.321928,
 170     3.4594316, 3.5849626, 3.7004397, 3.807355, 3.9068906, 4,        4.087463, 4.169925,  4.2479277,
 171     4.321928,  4.3923173, 4.4594316, 4.523562, 4.5849624, 4.643856, 4.70044,  4.7548876, 4.807355,
 172     4.857981,  4.9068904, 4.9541965, 5,        5.044394,  5.087463, 5.129283, 5.169925};
 173
 174 template <typename _Tp, __enable_if_t<is_unsigned<_Tp>::value, int> = 0>
 175 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
 176 __from_chars_integral(const char* __first, const char* __last, _Tp& __value, int __base) {
 177   if (__base == 10)
 178     return std::__from_chars_atoi(__first, __last, __value);
 179
 180   return std::__subject_seq_combinator(
 181       __first,
 182       __last,
 183       __value,
 184       [](const char* __p, const char* __lastp, _Tp& __val, int __b) -> from_chars_result {
 185         using __tl = numeric_limits<_Tp>;
 186         // __base is always between 2 and 36 inclusive.
 187         auto __digits = __tl::digits / __from_chars_log2f_lut[__b - 2];
 188         _Tp __x = __in_pattern(*__p++, __b).__val, __y = 0;
 189
 190         for (int __i = 1; __p != __lastp; ++__i, ++__p) {
 191           if (auto __c = __in_pattern(*__p, __b)) {
 192             if (__i < __digits - 1)
 193               __x = __x * __b + __c.__val;
 194             else {
 195               if (!__itoa::__mul_overflowed(__x, __b, __x))
 196                 ++__p;
 197               __y = __c.__val;
 198               break;
 199             }
 200           } else
 201             break;
 202         }
 203
 204         if (__p == __lastp || !__in_pattern(*__p, __b)) {
 205           if (__tl::max() - __x >= __y) {
 206             __val = __x + __y;
 207             return {__p, {}};
 208           }
 209         }
 210         return {__p, errc::result_out_of_range};
 211       },
 212       __base);
 213 }
 214
 215 template <typename _Tp, __enable_if_t<is_signed<_Tp>::value, int> = 0>
 216 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
 217 __from_chars_integral(const char* __first, const char* __last, _Tp& __value, int __base) {
 218   using __t = decltype(std::__to_unsigned_like(__value));
 219   return std::__sign_combinator(__first, __last, __value, __from_chars_integral<__t>, __base);
 220 }
 221
 222 template <typename _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
 223 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
 224 from_chars(const char* __first, const char* __last, _Tp& __value) {
 225   return std::__from_chars_atoi(__first, __last, __value);
 226 }
 227
 228 template <typename _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
 229 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
 230 from_chars(const char* __first, const char* __last, _Tp& __value, int __base) {
 231   _LIBCPP_ASSERT_UNCATEGORIZED(2 <= __base && __base <= 36, "base not in [2, 36]");
 232   return std::__from_chars_integral(__first, __last, __value, __base);
 233 }
 234 #endif // _LIBCPP_STD_VER >= 17
 235
 236 _LIBCPP_END_NAMESPACE_STD
 237
 238 _LIBCPP_POP_MACROS
 239
 240 #endif // _LIBCPP___CHARCONV_FROM_CHARS_INTEGRAL_H