mirror of
https://github.com/autc04/Retro68.git
synced 2024-12-02 03:50:17 +00:00
659 lines
16 KiB
C++
659 lines
16 KiB
C++
// Primitive numeric conversions (to_chars and from_chars) -*- C++ -*-
|
|
|
|
// Copyright (C) 2017-2018 Free Software Foundation, Inc.
|
|
//
|
|
// This file is part of the GNU ISO C++ Library. This library is free
|
|
// software; you can redistribute it and/or modify it under the
|
|
// terms of the GNU General Public License as published by the
|
|
// Free Software Foundation; either version 3, or (at your option)
|
|
// any later version.
|
|
|
|
// This library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
|
|
// Under Section 7 of GPL version 3, you are granted additional
|
|
// permissions described in the GCC Runtime Library Exception, version
|
|
// 3.1, as published by the Free Software Foundation.
|
|
|
|
// You should have received a copy of the GNU General Public License and
|
|
// a copy of the GCC Runtime Library Exception along with this program;
|
|
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
// <http://www.gnu.org/licenses/>.
|
|
|
|
/** @file include/charconv
|
|
* This is a Standard C++ Library header.
|
|
*/
|
|
|
|
#ifndef _GLIBCXX_CHARCONV
|
|
#define _GLIBCXX_CHARCONV 1
|
|
|
|
#pragma GCC system_header
|
|
|
|
#if __cplusplus >= 201402L
|
|
|
|
#include <type_traits>
|
|
#include <limits>
|
|
#include <cctype>
|
|
#include <bits/error_constants.h> // for std::errc
|
|
|
|
namespace std _GLIBCXX_VISIBILITY(default)
|
|
{
|
|
_GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|
|
|
/// Result type of std::to_chars
|
|
struct to_chars_result
|
|
{
|
|
char* ptr;
|
|
errc ec;
|
|
};
|
|
|
|
/// Result type of std::from_chars
|
|
struct from_chars_result
|
|
{
|
|
const char* ptr;
|
|
errc ec;
|
|
};
|
|
|
|
namespace __detail
|
|
{
|
|
template<typename _Tp, typename... _Types>
|
|
using __is_one_of = __or_<is_same<_Tp, _Types>...>;
|
|
|
|
template<typename _Tp>
|
|
using __is_int_to_chars_type = __and_<is_integral<_Tp>,
|
|
__not_<__is_one_of<_Tp, bool, char16_t, char32_t
|
|
#if _GLIBCXX_USE_WCHAR_T
|
|
, wchar_t
|
|
#endif
|
|
>>>;
|
|
|
|
template<typename _Tp>
|
|
using __integer_to_chars_result_type
|
|
= enable_if_t<__is_int_to_chars_type<_Tp>::value, to_chars_result>;
|
|
|
|
template<typename _Tp>
|
|
using __unsigned_least_t
|
|
= conditional_t<(sizeof(_Tp) <= sizeof(int)), unsigned int,
|
|
conditional_t<(sizeof(_Tp) <= sizeof(long)), unsigned long,
|
|
conditional_t<(sizeof(_Tp) <= sizeof(long long)), unsigned long long,
|
|
#if _GLIBCXX_USE_INT128
|
|
conditional_t<(sizeof(_Tp) <= sizeof(__int128)), unsigned __int128,
|
|
#endif
|
|
void
|
|
#if _GLIBCXX_USE_INT128
|
|
>
|
|
#endif
|
|
>>>;
|
|
|
|
// Generic implementation for arbitrary bases.
|
|
template<typename _Tp>
|
|
constexpr unsigned
|
|
__to_chars_len(_Tp __value, int __base = 10) noexcept
|
|
{
|
|
static_assert(is_integral<_Tp>::value, "implementation bug");
|
|
static_assert(is_unsigned<_Tp>::value, "implementation bug");
|
|
|
|
unsigned __n = 1;
|
|
const int __b2 = __base * __base;
|
|
const int __b3 = __b2 * __base;
|
|
const int __b4 = __b3 * __base;
|
|
for (;;)
|
|
{
|
|
if (__value < __base) return __n;
|
|
if (__value < __b2) return __n + 1;
|
|
if (__value < __b3) return __n + 2;
|
|
if (__value < __b4) return __n + 3;
|
|
__value /= (unsigned)__b4;
|
|
__n += 4;
|
|
}
|
|
}
|
|
|
|
template<typename _Tp>
|
|
constexpr unsigned
|
|
__to_chars_len_2(_Tp __value) noexcept
|
|
{
|
|
static_assert(is_integral<_Tp>::value, "implementation bug");
|
|
static_assert(is_unsigned<_Tp>::value, "implementation bug");
|
|
|
|
constexpr size_t __nbits = __CHAR_BIT__ * sizeof(_Tp);
|
|
|
|
// N.B. __builtin_clzll is undefined if __value == 0, but std::to_chars
|
|
// handles zero values directly.
|
|
|
|
// For sizeof(_Tp) > 1 this is an order of magnitude faster than
|
|
// the generic __to_chars_len.
|
|
return __nbits
|
|
- (__builtin_clzll(__value)
|
|
- ((__CHAR_BIT__ * sizeof(long long)) - __nbits));
|
|
}
|
|
|
|
template<typename _Tp>
|
|
constexpr unsigned
|
|
__to_chars_len_8(_Tp __value) noexcept
|
|
{
|
|
static_assert(is_integral<_Tp>::value, "implementation bug");
|
|
static_assert(is_unsigned<_Tp>::value, "implementation bug");
|
|
|
|
constexpr size_t __nbits = __CHAR_BIT__ * sizeof(_Tp);
|
|
|
|
if _GLIBCXX17_CONSTEXPR (__nbits <= 16)
|
|
{
|
|
return __value > 077777u ? 6u
|
|
: __value > 07777u ? 5u
|
|
: __value > 0777u ? 4u
|
|
: __value > 077u ? 3u
|
|
: __value > 07u ? 2u
|
|
: 1u;
|
|
}
|
|
else
|
|
return __to_chars_len(__value, 8);
|
|
}
|
|
|
|
// Generic implementation for arbitrary bases.
|
|
template<typename _Tp>
|
|
to_chars_result
|
|
__to_chars(char* __first, char* __last, _Tp __val, int __base) noexcept
|
|
{
|
|
static_assert(is_integral<_Tp>::value, "implementation bug");
|
|
static_assert(is_unsigned<_Tp>::value, "implementation bug");
|
|
|
|
to_chars_result __res;
|
|
|
|
const unsigned __len = __to_chars_len(__val, __base);
|
|
|
|
if (__builtin_expect((__last - __first) < __len, 0))
|
|
{
|
|
__res.ptr = __last;
|
|
__res.ec = errc::value_too_large;
|
|
return __res;
|
|
}
|
|
|
|
unsigned __pos = __len - 1;
|
|
|
|
static constexpr char __digits[]
|
|
= "0123456789abcdefghijklmnopqrstuvwxyz";
|
|
|
|
while (__val >= __base)
|
|
{
|
|
auto const __quo = __val / __base;
|
|
auto const __rem = __val % __base;
|
|
__first[__pos--] = __digits[__rem];
|
|
__val = __quo;
|
|
}
|
|
*__first = __digits[__val];
|
|
|
|
__res.ptr = __first + __len;
|
|
__res.ec = {};
|
|
return __res;
|
|
}
|
|
|
|
template<typename _Tp>
|
|
__integer_to_chars_result_type<_Tp>
|
|
__to_chars_16(char* __first, char* __last, _Tp __val) noexcept
|
|
{
|
|
static_assert(is_integral<_Tp>::value, "implementation bug");
|
|
static_assert(is_unsigned<_Tp>::value, "implementation bug");
|
|
|
|
to_chars_result __res;
|
|
|
|
const unsigned __len = __to_chars_len(__val, 0x10);
|
|
|
|
if (__builtin_expect((__last - __first) < __len, 0))
|
|
{
|
|
__res.ptr = __last;
|
|
__res.ec = errc::value_too_large;
|
|
return __res;
|
|
}
|
|
|
|
static constexpr char __digits[513] =
|
|
"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"
|
|
"202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f"
|
|
"404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f"
|
|
"606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f"
|
|
"808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f"
|
|
"a0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
|
|
"c0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
|
|
"e0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";
|
|
unsigned __pos = __len - 1;
|
|
while (__val >= 0x100)
|
|
{
|
|
auto const __num = (__val % 0x100) * 2;
|
|
__val /= 0x100;
|
|
__first[__pos] = __digits[__num + 1];
|
|
__first[__pos - 1] = __digits[__num];
|
|
__pos -= 2;
|
|
}
|
|
if (__val >= 0x10)
|
|
{
|
|
auto const __num = __val * 2;
|
|
__first[__pos] = __digits[__num + 1];
|
|
__first[__pos - 1] = __digits[__num];
|
|
}
|
|
else
|
|
__first[__pos] = "0123456789abcdef"[__val];
|
|
__res.ptr = __first + __len;
|
|
__res.ec = {};
|
|
return __res;
|
|
}
|
|
|
|
template<typename _Tp>
|
|
__integer_to_chars_result_type<_Tp>
|
|
__to_chars_10(char* __first, char* __last, _Tp __val) noexcept
|
|
{
|
|
static_assert(is_integral<_Tp>::value, "implementation bug");
|
|
static_assert(is_unsigned<_Tp>::value, "implementation bug");
|
|
|
|
to_chars_result __res;
|
|
|
|
const unsigned __len = __to_chars_len(__val, 10);
|
|
|
|
if (__builtin_expect((__last - __first) < __len, 0))
|
|
{
|
|
__res.ptr = __last;
|
|
__res.ec = errc::value_too_large;
|
|
return __res;
|
|
}
|
|
|
|
static constexpr char __digits[201] =
|
|
"0001020304050607080910111213141516171819"
|
|
"2021222324252627282930313233343536373839"
|
|
"4041424344454647484950515253545556575859"
|
|
"6061626364656667686970717273747576777879"
|
|
"8081828384858687888990919293949596979899";
|
|
unsigned __pos = __len - 1;
|
|
while (__val >= 100)
|
|
{
|
|
auto const __num = (__val % 100) * 2;
|
|
__val /= 100;
|
|
__first[__pos] = __digits[__num + 1];
|
|
__first[__pos - 1] = __digits[__num];
|
|
__pos -= 2;
|
|
}
|
|
if (__val >= 10)
|
|
{
|
|
auto const __num = __val * 2;
|
|
__first[__pos] = __digits[__num + 1];
|
|
__first[__pos - 1] = __digits[__num];
|
|
}
|
|
else
|
|
__first[__pos] = '0' + __val;
|
|
__res.ptr = __first + __len;
|
|
__res.ec = {};
|
|
return __res;
|
|
}
|
|
|
|
template<typename _Tp>
|
|
__integer_to_chars_result_type<_Tp>
|
|
__to_chars_8(char* __first, char* __last, _Tp __val) noexcept
|
|
{
|
|
static_assert(is_integral<_Tp>::value, "implementation bug");
|
|
static_assert(is_unsigned<_Tp>::value, "implementation bug");
|
|
|
|
to_chars_result __res;
|
|
|
|
const unsigned __len = __to_chars_len_8(__val);
|
|
|
|
if (__builtin_expect((__last - __first) < __len, 0))
|
|
{
|
|
__res.ptr = __last;
|
|
__res.ec = errc::value_too_large;
|
|
return __res;
|
|
}
|
|
|
|
static constexpr char __digits[129] =
|
|
"00010203040506071011121314151617"
|
|
"20212223242526273031323334353637"
|
|
"40414243444546475051525354555657"
|
|
"60616263646566677071727374757677";
|
|
unsigned __pos = __len - 1;
|
|
while (__val >= 0100)
|
|
{
|
|
auto const __num = (__val % 0100) * 2;
|
|
__val /= 0100;
|
|
__first[__pos] = __digits[__num + 1];
|
|
__first[__pos - 1] = __digits[__num];
|
|
__pos -= 2;
|
|
}
|
|
if (__val >= 010)
|
|
{
|
|
auto const __num = __val * 2;
|
|
__first[__pos] = __digits[__num + 1];
|
|
__first[__pos - 1] = __digits[__num];
|
|
}
|
|
else
|
|
__first[__pos] = '0' + __val;
|
|
__res.ptr = __first + __len;
|
|
__res.ec = {};
|
|
return __res;
|
|
}
|
|
|
|
template<typename _Tp>
|
|
__integer_to_chars_result_type<_Tp>
|
|
__to_chars_2(char* __first, char* __last, _Tp __val) noexcept
|
|
{
|
|
static_assert(is_integral<_Tp>::value, "implementation bug");
|
|
static_assert(is_unsigned<_Tp>::value, "implementation bug");
|
|
|
|
to_chars_result __res;
|
|
|
|
const unsigned __len = __to_chars_len_2(__val);
|
|
|
|
if (__builtin_expect((__last - __first) < __len, 0))
|
|
{
|
|
__res.ptr = __last;
|
|
__res.ec = errc::value_too_large;
|
|
return __res;
|
|
}
|
|
|
|
unsigned __pos = __len - 1;
|
|
|
|
while (__pos)
|
|
{
|
|
__first[__pos--] = '0' + (__val & 1);
|
|
__val >>= 1;
|
|
}
|
|
*__first = '0' + (__val & 1);
|
|
|
|
__res.ptr = __first + __len;
|
|
__res.ec = {};
|
|
return __res;
|
|
}
|
|
|
|
} // namespace __detail
|
|
|
|
template<typename _Tp>
|
|
__detail::__integer_to_chars_result_type<_Tp>
|
|
to_chars(char* __first, char* __last, _Tp __value, int __base = 10)
|
|
{
|
|
__glibcxx_assert(2 <= __base && __base <= 36);
|
|
|
|
using _Up = __detail::__unsigned_least_t<_Tp>;
|
|
_Up __unsigned_val = __value;
|
|
|
|
if (__value == 0 && __first != __last)
|
|
{
|
|
*__first = '0';
|
|
return { __first + 1, errc{} };
|
|
}
|
|
|
|
if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
|
|
if (__value < 0)
|
|
{
|
|
if (__builtin_expect(__first != __last, 1))
|
|
*__first++ = '-';
|
|
__unsigned_val = _Up(~__value) + _Up(1);
|
|
}
|
|
|
|
switch (__base)
|
|
{
|
|
case 16:
|
|
return __detail::__to_chars_16(__first, __last, __unsigned_val);
|
|
case 10:
|
|
return __detail::__to_chars_10(__first, __last, __unsigned_val);
|
|
case 8:
|
|
return __detail::__to_chars_8(__first, __last, __unsigned_val);
|
|
case 2:
|
|
return __detail::__to_chars_2(__first, __last, __unsigned_val);
|
|
default:
|
|
return __detail::__to_chars(__first, __last, __unsigned_val, __base);
|
|
}
|
|
}
|
|
|
|
namespace __detail
|
|
{
|
|
template<typename _Tp>
|
|
bool
|
|
__raise_and_add(_Tp& __val, int __base, unsigned char __c)
|
|
{
|
|
if (__builtin_mul_overflow(__val, __base, &__val)
|
|
|| __builtin_add_overflow(__val, __c, &__val))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
/// std::from_chars implementation for integers in base 2.
|
|
template<typename _Tp>
|
|
bool
|
|
__from_chars_binary(const char*& __first, const char* __last, _Tp& __val)
|
|
{
|
|
static_assert(is_integral<_Tp>::value, "implementation bug");
|
|
static_assert(is_unsigned<_Tp>::value, "implementation bug");
|
|
|
|
const ptrdiff_t __len = __last - __first;
|
|
int __i = 0;
|
|
while (__i < __len)
|
|
{
|
|
const unsigned char __c = (unsigned)__first[__i] - '0';
|
|
if (__c < 2)
|
|
__val = (__val << 1) | __c;
|
|
else
|
|
break;
|
|
__i++;
|
|
}
|
|
__first += __i;
|
|
return __i <= (sizeof(_Tp) * __CHAR_BIT__);
|
|
}
|
|
|
|
/// std::from_chars implementation for integers in bases 3 to 10.
|
|
template<typename _Tp>
|
|
bool
|
|
__from_chars_digit(const char*& __first, const char* __last, _Tp& __val,
|
|
int __base)
|
|
{
|
|
static_assert(is_integral<_Tp>::value, "implementation bug");
|
|
static_assert(is_unsigned<_Tp>::value, "implementation bug");
|
|
|
|
auto __matches = [__base](char __c) {
|
|
return '0' <= __c && __c <= ('0' + (__base - 1));
|
|
};
|
|
|
|
while (__first != __last)
|
|
{
|
|
const char __c = *__first;
|
|
if (__matches(__c))
|
|
{
|
|
if (!__raise_and_add(__val, __base, __c - '0'))
|
|
{
|
|
while (++__first != __last && __matches(*__first))
|
|
;
|
|
return false;
|
|
}
|
|
__first++;
|
|
}
|
|
else
|
|
return true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
constexpr unsigned char
|
|
__from_chars_alpha_to_num(char __c)
|
|
{
|
|
switch (__c)
|
|
{
|
|
case 'a':
|
|
case 'A':
|
|
return 10;
|
|
case 'b':
|
|
case 'B':
|
|
return 11;
|
|
case 'c':
|
|
case 'C':
|
|
return 12;
|
|
case 'd':
|
|
case 'D':
|
|
return 13;
|
|
case 'e':
|
|
case 'E':
|
|
return 14;
|
|
case 'f':
|
|
case 'F':
|
|
return 15;
|
|
case 'g':
|
|
case 'G':
|
|
return 16;
|
|
case 'h':
|
|
case 'H':
|
|
return 17;
|
|
case 'i':
|
|
case 'I':
|
|
return 18;
|
|
case 'j':
|
|
case 'J':
|
|
return 19;
|
|
case 'k':
|
|
case 'K':
|
|
return 20;
|
|
case 'l':
|
|
case 'L':
|
|
return 21;
|
|
case 'm':
|
|
case 'M':
|
|
return 22;
|
|
case 'n':
|
|
case 'N':
|
|
return 23;
|
|
case 'o':
|
|
case 'O':
|
|
return 24;
|
|
case 'p':
|
|
case 'P':
|
|
return 25;
|
|
case 'q':
|
|
case 'Q':
|
|
return 26;
|
|
case 'r':
|
|
case 'R':
|
|
return 27;
|
|
case 's':
|
|
case 'S':
|
|
return 28;
|
|
case 't':
|
|
case 'T':
|
|
return 29;
|
|
case 'u':
|
|
case 'U':
|
|
return 30;
|
|
case 'v':
|
|
case 'V':
|
|
return 31;
|
|
case 'w':
|
|
case 'W':
|
|
return 32;
|
|
case 'x':
|
|
case 'X':
|
|
return 33;
|
|
case 'y':
|
|
case 'Y':
|
|
return 34;
|
|
case 'z':
|
|
case 'Z':
|
|
return 35;
|
|
}
|
|
return std::numeric_limits<unsigned char>::max();
|
|
}
|
|
|
|
/// std::from_chars implementation for integers in bases 11 to 26.
|
|
template<typename _Tp>
|
|
bool
|
|
__from_chars_alnum(const char*& __first, const char* __last, _Tp& __val,
|
|
int __base)
|
|
{
|
|
bool __valid = true;
|
|
while (__first != __last)
|
|
{
|
|
unsigned char __c = *__first;
|
|
if (std::isdigit(__c))
|
|
__c -= '0';
|
|
else
|
|
{
|
|
__c = __from_chars_alpha_to_num(__c);
|
|
if (__c >= __base)
|
|
break;
|
|
}
|
|
|
|
if (__builtin_expect(__valid, 1))
|
|
__valid = __raise_and_add(__val, __base, __c);
|
|
__first++;
|
|
}
|
|
return __valid;
|
|
}
|
|
|
|
template<typename _Tp>
|
|
using __integer_from_chars_result_type
|
|
= enable_if_t<__is_int_to_chars_type<_Tp>::value, from_chars_result>;
|
|
|
|
} // namespace __detail
|
|
|
|
/// std::from_chars for integral types.
|
|
template<typename _Tp>
|
|
__detail::__integer_from_chars_result_type<_Tp>
|
|
from_chars(const char* __first, const char* __last, _Tp& __value,
|
|
int __base = 10)
|
|
{
|
|
__glibcxx_assert(2 <= __base && __base <= 36);
|
|
|
|
from_chars_result __res{__first, {}};
|
|
|
|
int __sign = 1;
|
|
if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
|
|
if (__first != __last && *__first == '-')
|
|
{
|
|
__sign = -1;
|
|
++__first;
|
|
}
|
|
|
|
using _Up = __detail::__unsigned_least_t<_Tp>;
|
|
_Up __val = 0;
|
|
|
|
const auto __start = __first;
|
|
bool __valid;
|
|
if (__base == 2)
|
|
__valid = __detail::__from_chars_binary(__first, __last, __val);
|
|
else if (__base <= 10)
|
|
__valid = __detail::__from_chars_digit(__first, __last, __val, __base);
|
|
else
|
|
__valid = __detail::__from_chars_alnum(__first, __last, __val, __base);
|
|
|
|
if (__builtin_expect(__first == __start, 0))
|
|
__res.ec = errc::invalid_argument;
|
|
else
|
|
{
|
|
__res.ptr = __first;
|
|
if (!__valid)
|
|
__res.ec = errc::result_out_of_range;
|
|
else
|
|
{
|
|
if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
|
|
{
|
|
_Tp __tmp;
|
|
if (__builtin_mul_overflow(__val, __sign, &__tmp))
|
|
__res.ec = errc::result_out_of_range;
|
|
else
|
|
__value = __tmp;
|
|
}
|
|
else
|
|
{
|
|
if _GLIBCXX17_CONSTEXPR
|
|
(numeric_limits<_Up>::max() > numeric_limits<_Tp>::max())
|
|
{
|
|
if (__val > numeric_limits<_Tp>::max())
|
|
__res.ec = errc::result_out_of_range;
|
|
else
|
|
__value = __val;
|
|
}
|
|
else
|
|
__value = __val;
|
|
}
|
|
}
|
|
}
|
|
return __res;
|
|
}
|
|
|
|
_GLIBCXX_END_NAMESPACE_VERSION
|
|
} // namespace std
|
|
#endif // C++14
|
|
#endif // _GLIBCXX_CHARCONV
|