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