1// -*- C++ -*- 2//===------------------------------ charconv ------------------------------===// 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 11#define _LIBCPP_CHARCONV 12 13/* 14 charconv synopsis 15 16namespace std { 17 18 // floating-point format for primitive numerical conversion 19 enum class chars_format { 20 scientific = unspecified, 21 fixed = unspecified, 22 hex = unspecified, 23 general = fixed | scientific 24 }; 25 26 // 23.20.2, primitive numerical output conversion 27 struct to_chars_result { 28 char* ptr; 29 errc ec; 30 }; 31 32 to_chars_result to_chars(char* first, char* last, see below value, 33 int base = 10); 34 35 to_chars_result to_chars(char* first, char* last, float value); 36 to_chars_result to_chars(char* first, char* last, double value); 37 to_chars_result to_chars(char* first, char* last, long double value); 38 39 to_chars_result to_chars(char* first, char* last, float value, 40 chars_format fmt); 41 to_chars_result to_chars(char* first, char* last, double value, 42 chars_format fmt); 43 to_chars_result to_chars(char* first, char* last, long double value, 44 chars_format fmt); 45 46 to_chars_result to_chars(char* first, char* last, float value, 47 chars_format fmt, int precision); 48 to_chars_result to_chars(char* first, char* last, double value, 49 chars_format fmt, int precision); 50 to_chars_result to_chars(char* first, char* last, long double value, 51 chars_format fmt, int precision); 52 53 // 23.20.3, primitive numerical input conversion 54 struct from_chars_result { 55 const char* ptr; 56 errc ec; 57 }; 58 59 from_chars_result from_chars(const char* first, const char* last, 60 see below& value, int base = 10); 61 62 from_chars_result from_chars(const char* first, const char* last, 63 float& value, 64 chars_format fmt = chars_format::general); 65 from_chars_result from_chars(const char* first, const char* last, 66 double& value, 67 chars_format fmt = chars_format::general); 68 from_chars_result from_chars(const char* first, const char* last, 69 long double& value, 70 chars_format fmt = chars_format::general); 71 72} // namespace std 73 74*/ 75 76#include <__config> 77#include <__availability> 78#include <__errc> 79#include <cmath> // for log2f 80#include <cstdint> 81#include <cstring> 82#include <limits> 83#include <type_traits> 84 85#include <__debug> 86 87#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 88#pragma GCC system_header 89#endif 90 91_LIBCPP_PUSH_MACROS 92#include <__undef_macros> 93 94_LIBCPP_BEGIN_NAMESPACE_STD 95 96namespace __itoa { 97_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_FUNC_VIS char* __u64toa(uint64_t __value, char* __buffer) _NOEXCEPT; 98_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_FUNC_VIS char* __u32toa(uint32_t __value, char* __buffer) _NOEXCEPT; 99} 100 101#ifndef _LIBCPP_CXX03_LANG 102 103enum class _LIBCPP_ENUM_VIS chars_format 104{ 105 scientific = 0x1, 106 fixed = 0x2, 107 hex = 0x4, 108 general = fixed | scientific 109}; 110 111struct _LIBCPP_TYPE_VIS to_chars_result 112{ 113 char* ptr; 114 errc ec; 115}; 116 117struct _LIBCPP_TYPE_VIS from_chars_result 118{ 119 const char* ptr; 120 errc ec; 121}; 122 123void to_chars(char*, char*, bool, int = 10) = delete; 124void from_chars(const char*, const char*, bool, int = 10) = delete; 125 126namespace __itoa 127{ 128 129static _LIBCPP_CONSTEXPR uint64_t __pow10_64[] = { 130 UINT64_C(0), 131 UINT64_C(10), 132 UINT64_C(100), 133 UINT64_C(1000), 134 UINT64_C(10000), 135 UINT64_C(100000), 136 UINT64_C(1000000), 137 UINT64_C(10000000), 138 UINT64_C(100000000), 139 UINT64_C(1000000000), 140 UINT64_C(10000000000), 141 UINT64_C(100000000000), 142 UINT64_C(1000000000000), 143 UINT64_C(10000000000000), 144 UINT64_C(100000000000000), 145 UINT64_C(1000000000000000), 146 UINT64_C(10000000000000000), 147 UINT64_C(100000000000000000), 148 UINT64_C(1000000000000000000), 149 UINT64_C(10000000000000000000), 150}; 151 152static _LIBCPP_CONSTEXPR uint32_t __pow10_32[] = { 153 UINT32_C(0), UINT32_C(10), UINT32_C(100), 154 UINT32_C(1000), UINT32_C(10000), UINT32_C(100000), 155 UINT32_C(1000000), UINT32_C(10000000), UINT32_C(100000000), 156 UINT32_C(1000000000), 157}; 158 159template <typename _Tp, typename = void> 160struct _LIBCPP_HIDDEN __traits_base 161{ 162 using type = uint64_t; 163 164#if !defined(_LIBCPP_COMPILER_MSVC) 165 static _LIBCPP_INLINE_VISIBILITY int __width(_Tp __v) 166 { 167 auto __t = (64 - __builtin_clzll(__v | 1)) * 1233 >> 12; 168 return __t - (__v < __pow10_64[__t]) + 1; 169 } 170#endif 171 172 _LIBCPP_AVAILABILITY_TO_CHARS 173 static _LIBCPP_INLINE_VISIBILITY char* __convert(_Tp __v, char* __p) 174 { 175 return __u64toa(__v, __p); 176 } 177 178 static _LIBCPP_INLINE_VISIBILITY decltype(__pow10_64)& __pow() { return __pow10_64; } 179}; 180 181template <typename _Tp> 182struct _LIBCPP_HIDDEN 183 __traits_base<_Tp, decltype(void(uint32_t{declval<_Tp>()}))> 184{ 185 using type = uint32_t; 186 187#if !defined(_LIBCPP_COMPILER_MSVC) 188 static _LIBCPP_INLINE_VISIBILITY int __width(_Tp __v) 189 { 190 auto __t = (32 - __builtin_clz(__v | 1)) * 1233 >> 12; 191 return __t - (__v < __pow10_32[__t]) + 1; 192 } 193#endif 194 195 _LIBCPP_AVAILABILITY_TO_CHARS 196 static _LIBCPP_INLINE_VISIBILITY char* __convert(_Tp __v, char* __p) 197 { 198 return __u32toa(__v, __p); 199 } 200 201 static _LIBCPP_INLINE_VISIBILITY decltype(__pow10_32)& __pow() { return __pow10_32; } 202}; 203 204template <typename _Tp> 205inline _LIBCPP_INLINE_VISIBILITY bool 206__mul_overflowed(unsigned char __a, _Tp __b, unsigned char& __r) 207{ 208 auto __c = __a * __b; 209 __r = __c; 210 return __c > numeric_limits<unsigned char>::max(); 211} 212 213template <typename _Tp> 214inline _LIBCPP_INLINE_VISIBILITY bool 215__mul_overflowed(unsigned short __a, _Tp __b, unsigned short& __r) 216{ 217 auto __c = __a * __b; 218 __r = __c; 219 return __c > numeric_limits<unsigned short>::max(); 220} 221 222template <typename _Tp> 223inline _LIBCPP_INLINE_VISIBILITY bool 224__mul_overflowed(_Tp __a, _Tp __b, _Tp& __r) 225{ 226 static_assert(is_unsigned<_Tp>::value, ""); 227#if !defined(_LIBCPP_COMPILER_MSVC) 228 return __builtin_mul_overflow(__a, __b, &__r); 229#else 230 bool __did = __b && (numeric_limits<_Tp>::max() / __b) < __a; 231 __r = __a * __b; 232 return __did; 233#endif 234} 235 236template <typename _Tp, typename _Up> 237inline _LIBCPP_INLINE_VISIBILITY bool 238__mul_overflowed(_Tp __a, _Up __b, _Tp& __r) 239{ 240 return __mul_overflowed(__a, static_cast<_Tp>(__b), __r); 241} 242 243template <typename _Tp> 244struct _LIBCPP_HIDDEN __traits : __traits_base<_Tp> 245{ 246 static _LIBCPP_CONSTEXPR int digits = numeric_limits<_Tp>::digits10 + 1; 247 using __traits_base<_Tp>::__pow; 248 using typename __traits_base<_Tp>::type; 249 250 // precondition: at least one non-zero character available 251 static _LIBCPP_INLINE_VISIBILITY char const* 252 __read(char const* __p, char const* __ep, type& __a, type& __b) 253 { 254 type __cprod[digits]; 255 int __j = digits - 1; 256 int __i = digits; 257 do 258 { 259 if (!('0' <= *__p && *__p <= '9')) 260 break; 261 __cprod[--__i] = *__p++ - '0'; 262 } while (__p != __ep && __i != 0); 263 264 __a = __inner_product(__cprod + __i + 1, __cprod + __j, __pow() + 1, 265 __cprod[__i]); 266 if (__mul_overflowed(__cprod[__j], __pow()[__j - __i], __b)) 267 --__p; 268 return __p; 269 } 270 271 template <typename _It1, typename _It2, class _Up> 272 static _LIBCPP_INLINE_VISIBILITY _Up 273 __inner_product(_It1 __first1, _It1 __last1, _It2 __first2, _Up __init) 274 { 275 for (; __first1 < __last1; ++__first1, ++__first2) 276 __init = __init + *__first1 * *__first2; 277 return __init; 278 } 279}; 280 281} // namespace __itoa 282 283template <typename _Tp> 284inline _LIBCPP_INLINE_VISIBILITY _Tp 285__complement(_Tp __x) 286{ 287 static_assert(is_unsigned<_Tp>::value, "cast to unsigned first"); 288 return _Tp(~__x + 1); 289} 290 291template <typename _Tp> 292inline _LIBCPP_INLINE_VISIBILITY typename make_unsigned<_Tp>::type 293__to_unsigned(_Tp __x) 294{ 295 return static_cast<typename make_unsigned<_Tp>::type>(__x); 296} 297 298template <typename _Tp> 299_LIBCPP_AVAILABILITY_TO_CHARS 300inline _LIBCPP_INLINE_VISIBILITY to_chars_result 301__to_chars_itoa(char* __first, char* __last, _Tp __value, true_type) 302{ 303 auto __x = __to_unsigned(__value); 304 if (__value < 0 && __first != __last) 305 { 306 *__first++ = '-'; 307 __x = __complement(__x); 308 } 309 310 return __to_chars_itoa(__first, __last, __x, false_type()); 311} 312 313template <typename _Tp> 314_LIBCPP_AVAILABILITY_TO_CHARS 315inline _LIBCPP_INLINE_VISIBILITY to_chars_result 316__to_chars_itoa(char* __first, char* __last, _Tp __value, false_type) 317{ 318 using __tx = __itoa::__traits<_Tp>; 319 auto __diff = __last - __first; 320 321#if !defined(_LIBCPP_COMPILER_MSVC) 322 if (__tx::digits <= __diff || __tx::__width(__value) <= __diff) 323 return {__tx::__convert(__value, __first), errc(0)}; 324 else 325 return {__last, errc::value_too_large}; 326#else 327 if (__tx::digits <= __diff) 328 return {__tx::__convert(__value, __first), {}}; 329 else 330 { 331 char __buf[__tx::digits]; 332 auto __p = __tx::__convert(__value, __buf); 333 auto __len = __p - __buf; 334 if (__len <= __diff) 335 { 336 _VSTD::memcpy(__first, __buf, __len); 337 return {__first + __len, {}}; 338 } 339 else 340 return {__last, errc::value_too_large}; 341 } 342#endif 343} 344 345template <typename _Tp> 346_LIBCPP_AVAILABILITY_TO_CHARS 347inline _LIBCPP_INLINE_VISIBILITY to_chars_result 348__to_chars_integral(char* __first, char* __last, _Tp __value, int __base, 349 true_type) 350{ 351 auto __x = __to_unsigned(__value); 352 if (__value < 0 && __first != __last) 353 { 354 *__first++ = '-'; 355 __x = __complement(__x); 356 } 357 358 return __to_chars_integral(__first, __last, __x, __base, false_type()); 359} 360 361template <typename _Tp> 362_LIBCPP_AVAILABILITY_TO_CHARS 363inline _LIBCPP_INLINE_VISIBILITY to_chars_result 364__to_chars_integral(char* __first, char* __last, _Tp __value, int __base, 365 false_type) 366{ 367 if (__base == 10) 368 return __to_chars_itoa(__first, __last, __value, false_type()); 369 370 auto __p = __last; 371 while (__p != __first) 372 { 373 auto __c = __value % __base; 374 __value /= __base; 375 *--__p = "0123456789abcdefghijklmnopqrstuvwxyz"[__c]; 376 if (__value == 0) 377 break; 378 } 379 380 auto __len = __last - __p; 381 if (__value != 0 || !__len) 382 return {__last, errc::value_too_large}; 383 else 384 { 385 _VSTD::memmove(__first, __p, __len); 386 return {__first + __len, {}}; 387 } 388} 389 390template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0> 391_LIBCPP_AVAILABILITY_TO_CHARS 392inline _LIBCPP_INLINE_VISIBILITY to_chars_result 393to_chars(char* __first, char* __last, _Tp __value) 394{ 395 return __to_chars_itoa(__first, __last, __value, is_signed<_Tp>()); 396} 397 398template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0> 399_LIBCPP_AVAILABILITY_TO_CHARS 400inline _LIBCPP_INLINE_VISIBILITY to_chars_result 401to_chars(char* __first, char* __last, _Tp __value, int __base) 402{ 403 _LIBCPP_ASSERT(2 <= __base && __base <= 36, "base not in [2, 36]"); 404 return __to_chars_integral(__first, __last, __value, __base, 405 is_signed<_Tp>()); 406} 407 408template <typename _It, typename _Tp, typename _Fn, typename... _Ts> 409inline _LIBCPP_INLINE_VISIBILITY from_chars_result 410__sign_combinator(_It __first, _It __last, _Tp& __value, _Fn __f, _Ts... __args) 411{ 412 using __tl = numeric_limits<_Tp>; 413 decltype(__to_unsigned(__value)) __x; 414 415 bool __neg = (__first != __last && *__first == '-'); 416 auto __r = __f(__neg ? __first + 1 : __first, __last, __x, __args...); 417 switch (__r.ec) 418 { 419 case errc::invalid_argument: 420 return {__first, __r.ec}; 421 case errc::result_out_of_range: 422 return __r; 423 default: 424 break; 425 } 426 427 if (__neg) 428 { 429 if (__x <= __complement(__to_unsigned(__tl::min()))) 430 { 431 __x = __complement(__x); 432 _VSTD::memcpy(&__value, &__x, sizeof(__x)); 433 return __r; 434 } 435 } 436 else 437 { 438 if (__x <= __tl::max()) 439 { 440 __value = __x; 441 return __r; 442 } 443 } 444 445 return {__r.ptr, errc::result_out_of_range}; 446} 447 448template <typename _Tp> 449inline _LIBCPP_INLINE_VISIBILITY bool 450__in_pattern(_Tp __c) 451{ 452 return '0' <= __c && __c <= '9'; 453} 454 455struct _LIBCPP_HIDDEN __in_pattern_result 456{ 457 bool __ok; 458 int __val; 459 460 explicit _LIBCPP_INLINE_VISIBILITY operator bool() const { return __ok; } 461}; 462 463template <typename _Tp> 464inline _LIBCPP_INLINE_VISIBILITY __in_pattern_result 465__in_pattern(_Tp __c, int __base) 466{ 467 if (__base <= 10) 468 return {'0' <= __c && __c < '0' + __base, __c - '0'}; 469 else if (__in_pattern(__c)) 470 return {true, __c - '0'}; 471 else if ('a' <= __c && __c < 'a' + __base - 10) 472 return {true, __c - 'a' + 10}; 473 else 474 return {'A' <= __c && __c < 'A' + __base - 10, __c - 'A' + 10}; 475} 476 477template <typename _It, typename _Tp, typename _Fn, typename... _Ts> 478inline _LIBCPP_INLINE_VISIBILITY from_chars_result 479__subject_seq_combinator(_It __first, _It __last, _Tp& __value, _Fn __f, 480 _Ts... __args) 481{ 482 auto __find_non_zero = [](_It __first, _It __last) { 483 for (; __first != __last; ++__first) 484 if (*__first != '0') 485 break; 486 return __first; 487 }; 488 489 auto __p = __find_non_zero(__first, __last); 490 if (__p == __last || !__in_pattern(*__p, __args...)) 491 { 492 if (__p == __first) 493 return {__first, errc::invalid_argument}; 494 else 495 { 496 __value = 0; 497 return {__p, {}}; 498 } 499 } 500 501 auto __r = __f(__p, __last, __value, __args...); 502 if (__r.ec == errc::result_out_of_range) 503 { 504 for (; __r.ptr != __last; ++__r.ptr) 505 { 506 if (!__in_pattern(*__r.ptr, __args...)) 507 break; 508 } 509 } 510 511 return __r; 512} 513 514template <typename _Tp, typename enable_if<is_unsigned<_Tp>::value, int>::type = 0> 515inline _LIBCPP_INLINE_VISIBILITY from_chars_result 516__from_chars_atoi(const char* __first, const char* __last, _Tp& __value) 517{ 518 using __tx = __itoa::__traits<_Tp>; 519 using __output_type = typename __tx::type; 520 521 return __subject_seq_combinator( 522 __first, __last, __value, 523 [](const char* __first, const char* __last, 524 _Tp& __value) -> from_chars_result { 525 __output_type __a, __b; 526 auto __p = __tx::__read(__first, __last, __a, __b); 527 if (__p == __last || !__in_pattern(*__p)) 528 { 529 __output_type __m = numeric_limits<_Tp>::max(); 530 if (__m >= __a && __m - __a >= __b) 531 { 532 __value = __a + __b; 533 return {__p, {}}; 534 } 535 } 536 return {__p, errc::result_out_of_range}; 537 }); 538} 539 540template <typename _Tp, typename enable_if<is_signed<_Tp>::value, int>::type = 0> 541inline _LIBCPP_INLINE_VISIBILITY from_chars_result 542__from_chars_atoi(const char* __first, const char* __last, _Tp& __value) 543{ 544 using __t = decltype(__to_unsigned(__value)); 545 return __sign_combinator(__first, __last, __value, __from_chars_atoi<__t>); 546} 547 548template <typename _Tp, typename enable_if<is_unsigned<_Tp>::value, int>::type = 0> 549inline _LIBCPP_INLINE_VISIBILITY from_chars_result 550__from_chars_integral(const char* __first, const char* __last, _Tp& __value, 551 int __base) 552{ 553 if (__base == 10) 554 return __from_chars_atoi(__first, __last, __value); 555 556 return __subject_seq_combinator( 557 __first, __last, __value, 558 [](const char* __p, const char* __last, _Tp& __value, 559 int __base) -> from_chars_result { 560 using __tl = numeric_limits<_Tp>; 561 auto __digits = __tl::digits / log2f(float(__base)); 562 _Tp __a = __in_pattern(*__p++, __base).__val, __b = 0; 563 564 for (int __i = 1; __p != __last; ++__i, ++__p) 565 { 566 if (auto __c = __in_pattern(*__p, __base)) 567 { 568 if (__i < __digits - 1) 569 __a = __a * __base + __c.__val; 570 else 571 { 572 if (!__itoa::__mul_overflowed(__a, __base, __a)) 573 ++__p; 574 __b = __c.__val; 575 break; 576 } 577 } 578 else 579 break; 580 } 581 582 if (__p == __last || !__in_pattern(*__p, __base)) 583 { 584 if (__tl::max() - __a >= __b) 585 { 586 __value = __a + __b; 587 return {__p, {}}; 588 } 589 } 590 return {__p, errc::result_out_of_range}; 591 }, 592 __base); 593} 594 595template <typename _Tp, typename enable_if<is_signed<_Tp>::value, int>::type = 0> 596inline _LIBCPP_INLINE_VISIBILITY from_chars_result 597__from_chars_integral(const char* __first, const char* __last, _Tp& __value, 598 int __base) 599{ 600 using __t = decltype(__to_unsigned(__value)); 601 return __sign_combinator(__first, __last, __value, 602 __from_chars_integral<__t>, __base); 603} 604 605template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0> 606inline _LIBCPP_INLINE_VISIBILITY from_chars_result 607from_chars(const char* __first, const char* __last, _Tp& __value) 608{ 609 return __from_chars_atoi(__first, __last, __value); 610} 611 612template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0> 613inline _LIBCPP_INLINE_VISIBILITY from_chars_result 614from_chars(const char* __first, const char* __last, _Tp& __value, int __base) 615{ 616 _LIBCPP_ASSERT(2 <= __base && __base <= 36, "base not in [2, 36]"); 617 return __from_chars_integral(__first, __last, __value, __base); 618} 619 620#endif // _LIBCPP_CXX03_LANG 621 622_LIBCPP_END_NAMESPACE_STD 623 624_LIBCPP_POP_MACROS 625 626#endif // _LIBCPP_CHARCONV 627