contrib/libc++/include/charconv

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