From 13ad334aa44e7cc2f0b2d29eab06ff1cd6153656 Mon Sep 17 00:00:00 2001 From: Matt Borland Date: Tue, 30 May 2023 15:45:22 +0200 Subject: [PATCH] Bulk macro replacement --- include/boost/charconv/detail/config.hpp | 42 ----- .../detail/fast_float/ascii_number.hpp | 18 +-- .../charconv/detail/fast_float/bigint.hpp | 148 +++++++++--------- .../fast_float/constexpr_feature_detect.hpp | 26 +-- .../detail/fast_float/decimal_to_binary.hpp | 8 +- .../detail/fast_float/digit_comparison.hpp | 50 +++--- .../charconv/detail/fast_float/fast_float.hpp | 6 +- .../charconv/detail/fast_float/fast_table.hpp | 1 + .../detail/fast_float/float_common.hpp | 68 ++++---- .../detail/fast_float/parse_number.hpp | 14 +- .../charconv/detail/significand_tables.hpp | 4 +- 11 files changed, 172 insertions(+), 213 deletions(-) diff --git a/include/boost/charconv/detail/config.hpp b/include/boost/charconv/detail/config.hpp index d057e4e..432c8c7 100644 --- a/include/boost/charconv/detail/config.hpp +++ b/include/boost/charconv/detail/config.hpp @@ -160,46 +160,4 @@ static_assert((BOOST_CHARCONV_ENDIAN_BIG_BYTE || BOOST_CHARCONV_ENDIAN_LITTLE_BY # define BOOST_CHARCONV_NO_CONSTEXPR_DETECTION #endif -#if !defined(BOOST_CHARCONV_NO_CONSTEXPR_DETECTION) && __cpp_lib_constexpr_algorithms >= 201806L -# define BOOST_CHARCONV_CXX20_CONSTEXPR constexpr -#else -# define BOOST_CHARCONV_CXX20_CONSTEXPR -#endif - -#if (defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) \ - || defined(__amd64) || defined(__aarch64__) || defined(_M_ARM64) \ - || defined(__MINGW64__) \ - || defined(__s390x__) \ - || (defined(__ppc64__) || defined(__PPC64__) || defined(__ppc64le__) || defined(__PPC64LE__)) ) - #define BOOST_CHARCONV_FASTFLOAT_64BIT 1 -#elif (defined(__i386) || defined(__i386__) || defined(_M_IX86) \ - || defined(__arm__) || defined(_M_ARM) || defined(__ppc__) \ - || defined(__MINGW32__) || defined(__EMSCRIPTEN__)) - #define BOOST_CHARCONV_FASTFLOAT_32BIT 1 -#else - // Need to check incrementally, since SIZE_MAX is a size_t, avoid overflow. - // We can never tell the register width, but the SIZE_MAX is a good approximation. - // UINTPTR_MAX and INTPTR_MAX are optional, so avoid them for max portability. - #if SIZE_MAX == 0xffff - #error Unknown platform (16-bit, unsupported) - #elif SIZE_MAX == 0xffffffff - #define BOOST_CHARCONV_FASTFLOAT_32BIT 1 - #elif SIZE_MAX == 0xffffffffffffffff - #define BOOST_CHARCONV_FASTFLOAT_64BIT 1 - #else - #error Unknown platform (not 32-bit, not 64-bit?) - #endif -#endif - -#ifdef __has_include -# if __has_include() -# if __cplusplus >= 202002L || BOOST_MSVC >= 202002L -# include -# if __cpp_lib_bit_cast >= 201806L -# define BOOST_CHARCONV_HAS_STD_BITCAST -# endif -# endif -# endif -#endif - #endif // BOOST_CHARCONV_DETAIL_CONFIG_HPP diff --git a/include/boost/charconv/detail/fast_float/ascii_number.hpp b/include/boost/charconv/detail/fast_float/ascii_number.hpp index 9f9730a..782b090 100644 --- a/include/boost/charconv/detail/fast_float/ascii_number.hpp +++ b/include/boost/charconv/detail/fast_float/ascii_number.hpp @@ -34,7 +34,7 @@ fastfloat_really_inline constexpr std::uint64_t byteswap(std::uint64_t val) { | (val & 0x00000000000000FF) << 56; } -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 std::uint64_t read_u64(const char *chars) { if (cpp20_and_in_constexpr()) { std::uint64_t val = 0; @@ -46,14 +46,14 @@ std::uint64_t read_u64(const char *chars) { } std::uint64_t val; ::memcpy(&val, chars, sizeof(std::uint64_t)); -#if FASTFLOAT_IS_BIG_ENDIAN == 1 +#if BOOST_CHARCONV_FASTFLOAT_IS_BIG_ENDIAN == 1 // Need to read as-if the number was in little-endian order. val = byteswap(val); #endif return val; } -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 void write_u64(std::uint8_t *chars, std::uint64_t val) { if (cpp20_and_in_constexpr()) { for(int i = 0; i < 8; ++i) { @@ -63,7 +63,7 @@ void write_u64(std::uint8_t *chars, std::uint64_t val) { } return; } -#if FASTFLOAT_IS_BIG_ENDIAN == 1 +#if BOOST_CHARCONV_FASTFLOAT_IS_BIG_ENDIAN == 1 // Need to read as-if the number was in little-endian order. val = byteswap(val); #endif @@ -71,7 +71,7 @@ void write_u64(std::uint8_t *chars, std::uint64_t val) { } // credit @aqrit -fastfloat_really_inline FASTFLOAT_CONSTEXPR14 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 std::uint32_t parse_eight_digits_unrolled(std::uint64_t val) { const std::uint64_t mask = 0x000000FF000000FF; const std::uint64_t mul1 = 0x000F424000000064; // 100 + (1000000ULL << 32) @@ -92,7 +92,7 @@ std::uint32_t parse_eight_digits_unrolled(const char32_t *) noexcept { return 0; } -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 std::uint32_t parse_eight_digits_unrolled(const char *chars) noexcept { return parse_eight_digits_unrolled(read_u64(chars)); } @@ -113,7 +113,7 @@ bool is_made_of_eight_digits_fast(const char32_t *) noexcept { return false; } -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bool is_made_of_eight_digits_fast(const char *chars) noexcept { return is_made_of_eight_digits_fast(read_u64(chars)); } @@ -135,7 +135,7 @@ using parsed_number_string = parsed_number_string_t; // Assuming that you use no more than 19 digits, this will // parse an ASCII string. template -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 parsed_number_string_t parse_number_string(UC const *p, UC const * pend, parse_options_t options) noexcept { chars_format const fmt = options.format; UC const decimal_point = options.decimal_point; @@ -144,7 +144,7 @@ parsed_number_string_t parse_number_string(UC const *p, UC const * pend, par answer.valid = false; answer.too_many_digits = false; answer.negative = (*p == UC('-')); -#ifdef FASTFLOAT_ALLOWS_LEADING_PLUS // disabled by default +#ifdef BOOST_CHARCONV_FASTFLOAT_ALLOWS_LEADING_PLUS // disabled by default if ((*p == UC('-')) || (*p == UC('+'))) #else if (*p == UC('-')) // C++17 20.19.3.(7.1) explicitly forbids '+' sign here diff --git a/include/boost/charconv/detail/fast_float/bigint.hpp b/include/boost/charconv/detail/fast_float/bigint.hpp index 7083eb1..e3cb53b 100644 --- a/include/boost/charconv/detail/fast_float/bigint.hpp +++ b/include/boost/charconv/detail/fast_float/bigint.hpp @@ -22,12 +22,12 @@ namespace boost { namespace charconv { namespace detail { namespace fast_float { // architecture except for sparc, which emulates 128-bit multiplication. // we might have platforms where `CHAR_BIT` is not 8, so let's avoid // doing `8 * sizeof(limb)`. -#if defined(FASTFLOAT_64BIT) && !defined(__sparc) -#define FASTFLOAT_64BIT_LIMB 1 +#if defined(BOOST_CHARCONV_FASTFLOAT_64BIT) && !defined(__sparc) +#define BOOST_CHARCONV_FASTFLOAT_64BIT_LIMB 1 typedef uint64_t limb; constexpr size_t limb_bits = 64; #else -#define FASTFLOAT_32BIT_LIMB +#define BOOST_CHARCONV_FASTFLOAT_32BIT_LIMB typedef uint32_t limb; constexpr size_t limb_bits = 32; #endif @@ -56,27 +56,27 @@ struct stackvec { stackvec &operator=(stackvec &&other) = delete; // create stack vector from existing limb span. - FASTFLOAT_CONSTEXPR20 stackvec(limb_span s) { - FASTFLOAT_ASSERT(try_extend(s)); + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 stackvec(limb_span s) { + BOOST_CHARCONV_FASTFLOAT_ASSERT(try_extend(s)); } - FASTFLOAT_CONSTEXPR14 limb& operator[](size_t index) noexcept { - FASTFLOAT_DEBUG_ASSERT(index < length); + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 limb& operator[](size_t index) noexcept { + BOOST_CHARCONV_FASTFLOAT_DEBUG_ASSERT(index < length); return data[index]; } - FASTFLOAT_CONSTEXPR14 const limb& operator[](size_t index) const noexcept { - FASTFLOAT_DEBUG_ASSERT(index < length); + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 const limb& operator[](size_t index) const noexcept { + BOOST_CHARCONV_FASTFLOAT_DEBUG_ASSERT(index < length); return data[index]; } // index from the end of the container - FASTFLOAT_CONSTEXPR14 const limb& rindex(size_t index) const noexcept { - FASTFLOAT_DEBUG_ASSERT(index < length); + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 const limb& rindex(size_t index) const noexcept { + BOOST_CHARCONV_FASTFLOAT_DEBUG_ASSERT(index < length); size_t rindex = length - index - 1; return data[rindex]; } // set the length, without bounds checking. - FASTFLOAT_CONSTEXPR14 void set_len(size_t len) noexcept { + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 void set_len(size_t len) noexcept { length = uint16_t(len); } constexpr size_t len() const noexcept { @@ -89,12 +89,12 @@ struct stackvec { return size; } // append item to vector, without bounds checking - FASTFLOAT_CONSTEXPR14 void push_unchecked(limb value) noexcept { + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 void push_unchecked(limb value) noexcept { data[length] = value; length++; } // append item to vector, returning if item was added - FASTFLOAT_CONSTEXPR14 bool try_push(limb value) noexcept { + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 bool try_push(limb value) noexcept { if (len() < capacity()) { push_unchecked(value); return true; @@ -103,13 +103,13 @@ struct stackvec { } } // add items to the vector, from a span, without bounds checking - FASTFLOAT_CONSTEXPR20 void extend_unchecked(limb_span s) noexcept { + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 void extend_unchecked(limb_span s) noexcept { limb* ptr = data + length; std::copy_n(s.ptr, s.len(), ptr); set_len(len() + s.len()); } // try to add items to the vector, returning if items were added - FASTFLOAT_CONSTEXPR20 bool try_extend(limb_span s) noexcept { + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bool try_extend(limb_span s) noexcept { if (len() + s.len() <= capacity()) { extend_unchecked(s); return true; @@ -120,7 +120,7 @@ struct stackvec { // resize the vector, without bounds checking // if the new size is longer than the vector, assign value to each // appended item. - FASTFLOAT_CONSTEXPR20 + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 void resize_unchecked(size_t new_len, limb value) noexcept { if (new_len > len()) { size_t count = new_len - len(); @@ -133,7 +133,7 @@ struct stackvec { } } // try to resize the vector, returning if the vector was resized. - FASTFLOAT_CONSTEXPR20 bool try_resize(size_t new_len, limb value) noexcept { + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bool try_resize(size_t new_len, limb value) noexcept { if (new_len > capacity()) { return false; } else { @@ -144,7 +144,7 @@ struct stackvec { // check if any limbs are non-zero after the given index. // this needs to be done in reverse order, since the index // is relative to the most significant limbs. - FASTFLOAT_CONSTEXPR14 bool nonzero(size_t index) const noexcept { + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 bool nonzero(size_t index) const noexcept { while (index < len()) { if (rindex(index) != 0) { return true; @@ -154,27 +154,27 @@ struct stackvec { return false; } // normalize the big integer, so most-significant zero limbs are removed. - FASTFLOAT_CONSTEXPR14 void normalize() noexcept { + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 void normalize() noexcept { while (len() > 0 && rindex(0) == 0) { length--; } } }; -fastfloat_really_inline FASTFLOAT_CONSTEXPR14 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 uint64_t empty_hi64(bool& truncated) noexcept { truncated = false; return 0; } -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 uint64_t uint64_hi64(uint64_t r0, bool& truncated) noexcept { truncated = false; int shl = leading_zeroes(r0); return r0 << shl; } -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 uint64_t uint64_hi64(uint64_t r0, uint64_t r1, bool& truncated) noexcept { int shl = leading_zeroes(r0); if (shl == 0) { @@ -187,19 +187,19 @@ uint64_t uint64_hi64(uint64_t r0, uint64_t r1, bool& truncated) noexcept { } } -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 uint64_t uint32_hi64(uint32_t r0, bool& truncated) noexcept { return uint64_hi64(r0, truncated); } -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 uint64_t uint32_hi64(uint32_t r0, uint32_t r1, bool& truncated) noexcept { uint64_t x0 = r0; uint64_t x1 = r1; return uint64_hi64((x0 << 32) | x1, truncated); } -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 uint64_t uint32_hi64(uint32_t r0, uint32_t r1, uint32_t r2, bool& truncated) noexcept { uint64_t x0 = r0; uint64_t x1 = r1; @@ -211,7 +211,7 @@ uint64_t uint32_hi64(uint32_t r0, uint32_t r1, uint32_t r2, bool& truncated) noe // we want an efficient operation. for msvc, where // we don't have built-in intrinsics, this is still // pretty fast. -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 limb scalar_add(limb x, limb y, bool& overflow) noexcept { limb z; // gcc and clang @@ -231,9 +231,9 @@ limb scalar_add(limb x, limb y, bool& overflow) noexcept { } // multiply two small integers, getting both the high and low bits. -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 limb scalar_mul(limb x, limb y, limb& carry) noexcept { -#ifdef FASTFLOAT_64BIT_LIMB +#ifdef BOOST_CHARCONV_FASTFLOAT_64BIT_LIMB #if defined(__SIZEOF_INT128__) // GCC and clang both define it as an extension. __uint128_t z = __uint128_t(x) * __uint128_t(y) + __uint128_t(carry); @@ -259,7 +259,7 @@ limb scalar_mul(limb x, limb y, limb& carry) noexcept { // add scalar value to bigint starting from offset. // used in grade school multiplication template -inline FASTFLOAT_CONSTEXPR20 +inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bool small_add_from(stackvec& vec, limb y, size_t start) noexcept { size_t index = start; limb carry = y; @@ -270,28 +270,28 @@ bool small_add_from(stackvec& vec, limb y, size_t start) noexcept { index += 1; } if (carry != 0) { - FASTFLOAT_TRY(vec.try_push(carry)); + BOOST_CHARCONV_FASTFLOAT_TRY(vec.try_push(carry)); } return true; } // add scalar value to bigint. template -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bool small_add(stackvec& vec, limb y) noexcept { return small_add_from(vec, y, 0); } // multiply bigint by scalar value. template -inline FASTFLOAT_CONSTEXPR20 +inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bool small_mul(stackvec& vec, limb y) noexcept { limb carry = 0; for (size_t index = 0; index < vec.len(); index++) { vec[index] = scalar_mul(vec[index], y, carry); } if (carry != 0) { - FASTFLOAT_TRY(vec.try_push(carry)); + BOOST_CHARCONV_FASTFLOAT_TRY(vec.try_push(carry)); } return true; } @@ -299,12 +299,12 @@ bool small_mul(stackvec& vec, limb y) noexcept { // add bigint to bigint starting from index. // used in grade school multiplication template -FASTFLOAT_CONSTEXPR20 +BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bool large_add_from(stackvec& x, limb_span y, size_t start) noexcept { // the effective x buffer is from `xstart..x.len()`, so exit early // if we can't get that current range. if (x.len() < start || y.len() > x.len() - start) { - FASTFLOAT_TRY(x.try_resize(y.len() + start, 0)); + BOOST_CHARCONV_FASTFLOAT_TRY(x.try_resize(y.len() + start, 0)); } bool carry = false; @@ -323,21 +323,21 @@ bool large_add_from(stackvec& x, limb_span y, size_t start) noexcept { // handle overflow if (carry) { - FASTFLOAT_TRY(small_add_from(x, 1, y.len() + start)); + BOOST_CHARCONV_FASTFLOAT_TRY(small_add_from(x, 1, y.len() + start)); } return true; } // add bigint to bigint. template -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bool large_add_from(stackvec& x, limb_span y) noexcept { return large_add_from(x, y, 0); } // grade-school multiplication algorithm template -FASTFLOAT_CONSTEXPR20 +BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bool long_mul(stackvec& x, limb_span y) noexcept { limb_span xs = limb_span(x.data, x.len()); stackvec z(xs); @@ -345,17 +345,17 @@ bool long_mul(stackvec& x, limb_span y) noexcept { if (y.len() != 0) { limb y0 = y[0]; - FASTFLOAT_TRY(small_mul(x, y0)); + BOOST_CHARCONV_FASTFLOAT_TRY(small_mul(x, y0)); for (size_t index = 1; index < y.len(); index++) { limb yi = y[index]; stackvec zi; if (yi != 0) { // re-use the same buffer throughout zi.set_len(0); - FASTFLOAT_TRY(zi.try_extend(zs)); - FASTFLOAT_TRY(small_mul(zi, yi)); + BOOST_CHARCONV_FASTFLOAT_TRY(zi.try_extend(zs)); + BOOST_CHARCONV_FASTFLOAT_TRY(small_mul(zi, yi)); limb_span zis = limb_span(zi.data, zi.len()); - FASTFLOAT_TRY(large_add_from(x, zis, index)); + BOOST_CHARCONV_FASTFLOAT_TRY(large_add_from(x, zis, index)); } } } @@ -366,12 +366,12 @@ bool long_mul(stackvec& x, limb_span y) noexcept { // grade-school multiplication algorithm template -FASTFLOAT_CONSTEXPR20 +BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bool large_mul(stackvec& x, limb_span y) noexcept { if (y.len() == 1) { - FASTFLOAT_TRY(small_mul(x, y[0])); + BOOST_CHARCONV_FASTFLOAT_TRY(small_mul(x, y[0])); } else { - FASTFLOAT_TRY(long_mul(x, y)); + BOOST_CHARCONV_FASTFLOAT_TRY(long_mul(x, y)); } return true; } @@ -387,7 +387,7 @@ struct pow5_tables { 2384185791015625UL, 11920928955078125UL, 59604644775390625UL, 298023223876953125UL, 1490116119384765625UL, 7450580596923828125UL, }; -#ifdef FASTFLOAT_64BIT_LIMB +#ifdef BOOST_CHARCONV_FASTFLOAT_64BIT_LIMB constexpr static limb large_power_of_5[] = { 1414648277510068013UL, 9180637584431281687UL, 4539964771860779200UL, 10482974169319127550UL, 198276706040285095UL}; @@ -415,14 +415,14 @@ struct bigint : pow5_tables<> { // storage of the limbs, in little-endian order. stackvec vec; - FASTFLOAT_CONSTEXPR20 bigint(): vec() {} + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bigint(): vec() {} bigint(const bigint &) = delete; bigint &operator=(const bigint &) = delete; bigint(bigint &&) = delete; bigint &operator=(bigint &&other) = delete; - FASTFLOAT_CONSTEXPR20 bigint(uint64_t value): vec() { -#ifdef FASTFLOAT_64BIT_LIMB + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bigint(uint64_t value): vec() { +#ifdef BOOST_CHARCONV_FASTFLOAT_64BIT_LIMB vec.push_unchecked(value); #else vec.push_unchecked(uint32_t(value)); @@ -433,8 +433,8 @@ struct bigint : pow5_tables<> { // get the high 64 bits from the vector, and if bits were truncated. // this is to get the significant digits for the float. - FASTFLOAT_CONSTEXPR20 uint64_t hi64(bool& truncated) const noexcept { -#ifdef FASTFLOAT_64BIT_LIMB + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 uint64_t hi64(bool& truncated) const noexcept { +#ifdef BOOST_CHARCONV_FASTFLOAT_64BIT_LIMB if (vec.len() == 0) { return empty_hi64(truncated); } else if (vec.len() == 1) { @@ -465,7 +465,7 @@ struct bigint : pow5_tables<> { // positive, this is larger, otherwise they are equal. // the limbs are stored in little-endian order, so we // must compare the limbs in ever order. - FASTFLOAT_CONSTEXPR20 int compare(const bigint& other) const noexcept { + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 int compare(const bigint& other) const noexcept { if (vec.len() > other.vec.len()) { return 1; } else if (vec.len() < other.vec.len()) { @@ -486,14 +486,14 @@ struct bigint : pow5_tables<> { // shift left each limb n bits, carrying over to the new limb // returns true if we were able to shift all the digits. - FASTFLOAT_CONSTEXPR20 bool shl_bits(size_t n) noexcept { + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bool shl_bits(size_t n) noexcept { // Internally, for each item, we shift left by n, and add the previous // right shifted limb-bits. // For example, we transform (for u8) shifted left 2, to: // b10100100 b01000010 // b10 b10010001 b00001000 - FASTFLOAT_DEBUG_ASSERT(n != 0); - FASTFLOAT_DEBUG_ASSERT(n < sizeof(limb) * 8); + BOOST_CHARCONV_FASTFLOAT_DEBUG_ASSERT(n != 0); + BOOST_CHARCONV_FASTFLOAT_DEBUG_ASSERT(n < sizeof(limb) * 8); size_t shl = n; size_t shr = limb_bits - shl; @@ -512,8 +512,8 @@ struct bigint : pow5_tables<> { } // move the limbs left by `n` limbs. - FASTFLOAT_CONSTEXPR20 bool shl_limbs(size_t n) noexcept { - FASTFLOAT_DEBUG_ASSERT(n != 0); + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bool shl_limbs(size_t n) noexcept { + BOOST_CHARCONV_FASTFLOAT_DEBUG_ASSERT(n != 0); if (n + vec.len() > vec.capacity()) { return false; } else if (!vec.is_empty()) { @@ -533,24 +533,24 @@ struct bigint : pow5_tables<> { } // move the limbs left by `n` bits. - FASTFLOAT_CONSTEXPR20 bool shl(size_t n) noexcept { + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bool shl(size_t n) noexcept { size_t rem = n % limb_bits; size_t div = n / limb_bits; if (rem != 0) { - FASTFLOAT_TRY(shl_bits(rem)); + BOOST_CHARCONV_FASTFLOAT_TRY(shl_bits(rem)); } if (div != 0) { - FASTFLOAT_TRY(shl_limbs(div)); + BOOST_CHARCONV_FASTFLOAT_TRY(shl_limbs(div)); } return true; } // get the number of leading zeros in the bigint. - FASTFLOAT_CONSTEXPR20 int ctlz() const noexcept { + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 int ctlz() const noexcept { if (vec.is_empty()) { return 0; } else { -#ifdef FASTFLOAT_64BIT_LIMB +#ifdef BOOST_CHARCONV_FASTFLOAT_64BIT_LIMB return leading_zeroes(vec.rindex(0)); #else // no use defining a specialized leading_zeroes for a 32-bit type. @@ -561,34 +561,34 @@ struct bigint : pow5_tables<> { } // get the number of bits in the bigint. - FASTFLOAT_CONSTEXPR20 int bit_length() const noexcept { + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 int bit_length() const noexcept { int lz = ctlz(); return int(limb_bits * vec.len()) - lz; } - FASTFLOAT_CONSTEXPR20 bool mul(limb y) noexcept { + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bool mul(limb y) noexcept { return small_mul(vec, y); } - FASTFLOAT_CONSTEXPR20 bool add(limb y) noexcept { + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bool add(limb y) noexcept { return small_add(vec, y); } // multiply as if by 2 raised to a power. - FASTFLOAT_CONSTEXPR20 bool pow2(uint32_t exp) noexcept { + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bool pow2(uint32_t exp) noexcept { return shl(exp); } // multiply as if by 5 raised to a power. - FASTFLOAT_CONSTEXPR20 bool pow5(uint32_t exp) noexcept { + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bool pow5(uint32_t exp) noexcept { // multiply by a power of 5 size_t large_length = sizeof(large_power_of_5) / sizeof(limb); limb_span large = limb_span(large_power_of_5, large_length); while (exp >= large_step) { - FASTFLOAT_TRY(large_mul(vec, large)); + BOOST_CHARCONV_FASTFLOAT_TRY(large_mul(vec, large)); exp -= large_step; } -#ifdef FASTFLOAT_64BIT_LIMB +#ifdef BOOST_CHARCONV_FASTFLOAT_64BIT_LIMB uint32_t small_step = 27; limb max_native = 7450580596923828125UL; #else @@ -596,14 +596,14 @@ struct bigint : pow5_tables<> { limb max_native = 1220703125U; #endif while (exp >= small_step) { - FASTFLOAT_TRY(small_mul(vec, max_native)); + BOOST_CHARCONV_FASTFLOAT_TRY(small_mul(vec, max_native)); exp -= small_step; } if (exp != 0) { // Work around clang bug https://godbolt.org/z/zedh7rrhc // This is similar to https://github.com/llvm/llvm-project/issues/47746, // except the workaround described there don't work here - FASTFLOAT_TRY( + BOOST_CHARCONV_FASTFLOAT_TRY( small_mul(vec, limb(((void)small_power_of_5[0], small_power_of_5[exp]))) ); } @@ -612,8 +612,8 @@ struct bigint : pow5_tables<> { } // multiply as if by 10 raised to a power. - FASTFLOAT_CONSTEXPR20 bool pow10(uint32_t exp) noexcept { - FASTFLOAT_TRY(pow5(exp)); + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bool pow10(uint32_t exp) noexcept { + BOOST_CHARCONV_FASTFLOAT_TRY(pow5(exp)); return pow2(exp); } }; diff --git a/include/boost/charconv/detail/fast_float/constexpr_feature_detect.hpp b/include/boost/charconv/detail/fast_float/constexpr_feature_detect.hpp index 809d8d5..1ac1e4a 100644 --- a/include/boost/charconv/detail/fast_float/constexpr_feature_detect.hpp +++ b/include/boost/charconv/detail/fast_float/constexpr_feature_detect.hpp @@ -16,32 +16,32 @@ // Testing for https://wg21.link/N3652, adopted in C++14 #if __cpp_constexpr >= 201304 -#define FASTFLOAT_CONSTEXPR14 constexpr +#define BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 constexpr #else -#define FASTFLOAT_CONSTEXPR14 +#define BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 #endif #if defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L -#define FASTFLOAT_HAS_BIT_CAST 1 +#define BOOST_CHARCONV_FASTFLOAT_HAS_BIT_CAST 1 #else -#define FASTFLOAT_HAS_BIT_CAST 0 +#define BOOST_CHARCONV_FASTFLOAT_HAS_BIT_CAST 0 #endif #if defined(__cpp_lib_is_constant_evaluated) && __cpp_lib_is_constant_evaluated >= 201811L -#define FASTFLOAT_HAS_IS_CONSTANT_EVALUATED 1 +#define BOOST_CHARCONV_FASTFLOAT_HAS_IS_CONSTANT_EVALUATED 1 #else -#define FASTFLOAT_HAS_IS_CONSTANT_EVALUATED 0 +#define BOOST_CHARCONV_FASTFLOAT_HAS_IS_CONSTANT_EVALUATED 0 #endif // Testing for relevant C++20 constexpr library features -#if FASTFLOAT_HAS_IS_CONSTANT_EVALUATED \ - && FASTFLOAT_HAS_BIT_CAST \ +#if BOOST_CHARCONV_FASTFLOAT_HAS_IS_CONSTANT_EVALUATED \ + && BOOST_CHARCONV_FASTFLOAT_HAS_BIT_CAST \ && __cpp_lib_constexpr_algorithms >= 201806L /*For std::copy and std::fill*/ -#define FASTFLOAT_CONSTEXPR20 constexpr -#define FASTFLOAT_IS_CONSTEXPR 1 +#define BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 constexpr +#define BOOST_CHARCONV_FASTFLOAT_IS_CONSTEXPR 1 #else -#define FASTFLOAT_CONSTEXPR20 -#define FASTFLOAT_IS_CONSTEXPR 0 +#define BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 +#define BOOST_CHARCONV_FASTFLOAT_IS_CONSTEXPR 0 #endif -#endif // FASTFLOAT_CONSTEXPR_FEATURE_DETECT_H +#endif // BOOST_CHARCONV_FASTFLOAT_CONSTEXPR_FEATURE_DETECT_H diff --git a/include/boost/charconv/detail/fast_float/decimal_to_binary.hpp b/include/boost/charconv/detail/fast_float/decimal_to_binary.hpp index 0b68c3a..a8b5fdb 100644 --- a/include/boost/charconv/detail/fast_float/decimal_to_binary.hpp +++ b/include/boost/charconv/detail/fast_float/decimal_to_binary.hpp @@ -24,7 +24,7 @@ namespace boost { namespace charconv { namespace detail { namespace fast_float { // low part corresponding to the least significant bits. // template -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 value128 compute_product_approximation(int64_t q, uint64_t w) { const int index = 2 * int(q - powers::smallest_power_of_five); // For small values of q, e.g., q in [0,27], the answer is always exact because @@ -70,7 +70,7 @@ namespace detail { // create an adjusted mantissa, biased by the invalid power2 // for significant digits already multiplied by 10 ** q. template -fastfloat_really_inline FASTFLOAT_CONSTEXPR14 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 adjusted_mantissa compute_error_scaled(int64_t q, uint64_t w, int lz) noexcept { int hilz = int(w >> 63) ^ 1; adjusted_mantissa answer; @@ -83,7 +83,7 @@ adjusted_mantissa compute_error_scaled(int64_t q, uint64_t w, int lz) noexcept // w * 10 ** q, without rounding the representation up. // the power2 in the exponent will be adjusted by invalid_am_bias. template -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 adjusted_mantissa compute_error(int64_t q, uint64_t w) noexcept { int lz = leading_zeroes(w); w <<= lz; @@ -97,7 +97,7 @@ adjusted_mantissa compute_error(int64_t q, uint64_t w) noexcept { // return an adjusted_mantissa with a negative power of 2: the caller should recompute // in such cases. template -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 adjusted_mantissa compute_float(int64_t q, uint64_t w) noexcept { adjusted_mantissa answer; if ((w == 0) || (q < binary::smallest_power_of_ten())) { diff --git a/include/boost/charconv/detail/fast_float/digit_comparison.hpp b/include/boost/charconv/detail/fast_float/digit_comparison.hpp index 2c1a6d8..e69de9e 100644 --- a/include/boost/charconv/detail/fast_float/digit_comparison.hpp +++ b/include/boost/charconv/detail/fast_float/digit_comparison.hpp @@ -30,7 +30,7 @@ constexpr static uint64_t powers_of_ten_uint64[] = { // effect on performance: in order to have a faster algorithm, we'd need // to slow down performance for faster algorithms, and this is still fast. template -fastfloat_really_inline FASTFLOAT_CONSTEXPR14 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 int32_t scientific_exponent(parsed_number_string_t & num) noexcept { uint64_t mantissa = num.mantissa; int32_t exponent = int32_t(num.exponent); @@ -51,7 +51,7 @@ int32_t scientific_exponent(parsed_number_string_t & num) noexcept { // this converts a native floating-point number to an extended-precision float. template -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 adjusted_mantissa to_extended(T value) noexcept { using equiv_uint = typename binary_format::equiv_uint; constexpr equiv_uint exponent_mask = binary_format::exponent_mask(); @@ -61,7 +61,7 @@ adjusted_mantissa to_extended(T value) noexcept { adjusted_mantissa am; int32_t bias = binary_format::mantissa_explicit_bits() - binary_format::minimum_exponent(); equiv_uint bits; -#if FASTFLOAT_HAS_BIT_CAST +#if BOOST_CHARCONV_FASTFLOAT_HAS_BIT_CAST bits = std::bit_cast(value); #else ::memcpy(&bits, &value, sizeof(T)); @@ -84,7 +84,7 @@ adjusted_mantissa to_extended(T value) noexcept { // we are given a native float that represents b, so we need to adjust it // halfway between b and b+u. template -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 adjusted_mantissa to_extended_halfway(T value) noexcept { adjusted_mantissa am = to_extended(value); am.mantissa <<= 1; @@ -95,7 +95,7 @@ adjusted_mantissa to_extended_halfway(T value) noexcept { // round an extended-precision float to the nearest machine float. template -fastfloat_really_inline FASTFLOAT_CONSTEXPR14 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 void round(adjusted_mantissa& am, callback cb) noexcept { int32_t mantissa_shift = 64 - binary_format::mantissa_explicit_bits() - 1; if (-am.power2 >= mantissa_shift) { @@ -125,7 +125,7 @@ void round(adjusted_mantissa& am, callback cb) noexcept { } template -fastfloat_really_inline FASTFLOAT_CONSTEXPR14 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 void round_nearest_tie_even(adjusted_mantissa& am, int32_t shift, callback cb) noexcept { const uint64_t mask = (shift == 64) @@ -151,7 +151,7 @@ void round_nearest_tie_even(adjusted_mantissa& am, int32_t shift, callback cb) n am.mantissa += uint64_t(cb(is_odd, is_halfway, is_above)); } -fastfloat_really_inline FASTFLOAT_CONSTEXPR14 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 void round_down(adjusted_mantissa& am, int32_t shift) noexcept { if (shift == 64) { am.mantissa = 0; @@ -161,7 +161,7 @@ void round_down(adjusted_mantissa& am, int32_t shift) noexcept { am.power2 += shift; } template -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 void skip_zeros(UC const * & first, UC const * last) noexcept { uint64_t val; while (!cpp20_and_in_constexpr() && std::distance(first, last) >= int_cmp_len()) { @@ -182,7 +182,7 @@ void skip_zeros(UC const * & first, UC const * last) noexcept { // determine if any non-zero digits were truncated. // all characters must be valid digits. template -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bool is_truncated(UC const * first, UC const * last) noexcept { // do 8-bit optimizations, can just compare to 8 literal 0s. uint64_t val; @@ -202,22 +202,22 @@ bool is_truncated(UC const * first, UC const * last) noexcept { return false; } template -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 bool is_truncated(span s) noexcept { return is_truncated(s.ptr, s.ptr + s.len()); } -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 void parse_eight_digits(const char16_t*& , limb& , size_t& , size_t& ) noexcept { // currently unused } -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 void parse_eight_digits(const char32_t*& , limb& , size_t& , size_t& ) noexcept { // currently unused } -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 void parse_eight_digits(const char*& p, limb& value, size_t& counter, size_t& count) noexcept { value = value * 100000000 + parse_eight_digits_unrolled(p); p += 8; @@ -226,7 +226,7 @@ void parse_eight_digits(const char*& p, limb& value, size_t& counter, size_t& co } template -fastfloat_really_inline FASTFLOAT_CONSTEXPR14 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 void parse_one_digit(UC const *& p, limb& value, size_t& counter, size_t& count) noexcept { value = value * 10 + limb(*p - UC('0')); p++; @@ -234,13 +234,13 @@ void parse_one_digit(UC const *& p, limb& value, size_t& counter, size_t& count) count++; } -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 void add_native(bigint& big, limb power, limb value) noexcept { big.mul(power); big.add(value); } -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 void round_up_bigint(bigint& big, size_t& count) noexcept { // need to round-up the digits, but need to avoid rounding // ....9999 to ...10000, which could cause a false halfway point. @@ -250,7 +250,7 @@ void round_up_bigint(bigint& big, size_t& count) noexcept { // parse the significant digits into a big integer template -inline FASTFLOAT_CONSTEXPR20 +inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 void parse_mantissa(bigint& result, parsed_number_string_t& num, size_t max_digits, size_t& digits) noexcept { // try to minimize the number of big integer and scalar multiplication. // therefore, try to parse 8 digits at a time, and multiply by the largest @@ -258,7 +258,7 @@ void parse_mantissa(bigint& result, parsed_number_string_t& num, size_t max_ size_t counter = 0; digits = 0; limb value = 0; -#ifdef FASTFLOAT_64BIT_LIMB +#ifdef BOOST_CHARCONV_FASTFLOAT_64BIT_LIMB size_t step = 19; #else size_t step = 9; @@ -335,9 +335,9 @@ void parse_mantissa(bigint& result, parsed_number_string_t& num, size_t max_ } template -inline FASTFLOAT_CONSTEXPR20 +inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 adjusted_mantissa positive_digit_comp(bigint& bigmant, int32_t exponent) noexcept { - FASTFLOAT_ASSERT(bigmant.pow10(uint32_t(exponent))); + BOOST_CHARCONV_FASTFLOAT_ASSERT(bigmant.pow10(uint32_t(exponent))); adjusted_mantissa answer; bool truncated; answer.mantissa = bigmant.hi64(truncated); @@ -359,7 +359,7 @@ adjusted_mantissa positive_digit_comp(bigint& bigmant, int32_t exponent) noexcep // we then need to scale by `2^(f- e)`, and then the two significant digits // are of the same magnitude. template -inline FASTFLOAT_CONSTEXPR20 +inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 adjusted_mantissa negative_digit_comp(bigint& bigmant, adjusted_mantissa am, int32_t exponent) noexcept { bigint& real_digits = bigmant; int32_t real_exp = exponent; @@ -378,12 +378,12 @@ adjusted_mantissa negative_digit_comp(bigint& bigmant, adjusted_mantissa am, int int32_t pow2_exp = theor_exp - real_exp; uint32_t pow5_exp = uint32_t(-real_exp); if (pow5_exp != 0) { - FASTFLOAT_ASSERT(theor_digits.pow5(pow5_exp)); + BOOST_CHARCONV_FASTFLOAT_ASSERT(theor_digits.pow5(pow5_exp)); } if (pow2_exp > 0) { - FASTFLOAT_ASSERT(theor_digits.pow2(uint32_t(pow2_exp))); + BOOST_CHARCONV_FASTFLOAT_ASSERT(theor_digits.pow2(uint32_t(pow2_exp))); } else if (pow2_exp < 0) { - FASTFLOAT_ASSERT(real_digits.pow2(uint32_t(-pow2_exp))); + BOOST_CHARCONV_FASTFLOAT_ASSERT(real_digits.pow2(uint32_t(-pow2_exp))); } // compare digits, and use it to director rounding @@ -420,7 +420,7 @@ adjusted_mantissa negative_digit_comp(bigint& bigmant, adjusted_mantissa am, int // the actual digits. we then compare the big integer representations // of both, and use that to direct rounding. template -inline FASTFLOAT_CONSTEXPR20 +inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 adjusted_mantissa digit_comp(parsed_number_string_t& num, adjusted_mantissa am) noexcept { // remove the invalid exponent bias am.power2 -= invalid_am_bias; diff --git a/include/boost/charconv/detail/fast_float/fast_float.hpp b/include/boost/charconv/detail/fast_float/fast_float.hpp index 5b19457..e807c67 100644 --- a/include/boost/charconv/detail/fast_float/fast_float.hpp +++ b/include/boost/charconv/detail/fast_float/fast_float.hpp @@ -31,7 +31,7 @@ namespace boost { namespace charconv { namespace detail { namespace fast_float { * The default is `fast_float::chars_format::general` which allows both `fixed` and `scientific`. */ template -FASTFLOAT_CONSTEXPR20 +BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 from_chars_result_t from_chars(UC const * first, UC const * last, T &value, chars_format fmt = chars_format::general) noexcept; @@ -39,10 +39,10 @@ from_chars_result_t from_chars(UC const * first, UC const * last, * Like from_chars, but accepts an `options` argument to govern number parsing. */ template -FASTFLOAT_CONSTEXPR20 +BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 from_chars_result_t from_chars_advanced(UC const * first, UC const * last, T &value, parse_options_t options) noexcept; }}}} // namespace fast_float #include -#endif // FASTFLOAT_FAST_FLOAT_H +#endif // BOOST_CHARCONV_FASTFLOAT_FAST_FLOAT_H diff --git a/include/boost/charconv/detail/fast_float/fast_table.hpp b/include/boost/charconv/detail/fast_float/fast_table.hpp index 4c6b358..e08eb31 100644 --- a/include/boost/charconv/detail/fast_float/fast_table.hpp +++ b/include/boost/charconv/detail/fast_float/fast_table.hpp @@ -8,6 +8,7 @@ #ifndef BOOST_CHARCONV_DETAIL_FASTFLOAT_FAST_TABLE_HPP #define BOOST_CHARCONV_DETAIL_FASTFLOAT_FAST_TABLE_HPP +#include #include namespace boost { namespace charconv { namespace detail { namespace fast_float { diff --git a/include/boost/charconv/detail/fast_float/float_common.hpp b/include/boost/charconv/detail/fast_float/float_common.hpp index cb3ddcc..dfea597 100644 --- a/include/boost/charconv/detail/fast_float/float_common.hpp +++ b/include/boost/charconv/detail/fast_float/float_common.hpp @@ -36,7 +36,7 @@ using parse_options = parse_options_t; } -#if FASTFLOAT_HAS_BIT_CAST +#if BOOST_CHARCONV_FASTFLOAT_HAS_BIT_CAST #include #endif @@ -45,11 +45,11 @@ using parse_options = parse_options_t; || defined(__MINGW64__) \ || defined(__s390x__) \ || (defined(__ppc64__) || defined(__PPC64__) || defined(__ppc64le__) || defined(__PPC64LE__)) ) -#define FASTFLOAT_64BIT 1 +#define BOOST_CHARCONV_FASTFLOAT_64BIT 1 #elif (defined(__i386) || defined(__i386__) || defined(_M_IX86) \ || defined(__arm__) || defined(_M_ARM) || defined(__ppc__) \ || defined(__MINGW32__) || defined(__EMSCRIPTEN__)) -#define FASTFLOAT_32BIT 1 +#define BOOST_CHARCONV_FASTFLOAT_32BIT 1 #else // Need to check incrementally, since SIZE_MAX is a size_t, avoid overflow. // We can never tell the register width, but the SIZE_MAX is a good approximation. @@ -57,9 +57,9 @@ using parse_options = parse_options_t; #if SIZE_MAX == 0xffff #error Unknown platform (16-bit, unsupported) #elif SIZE_MAX == 0xffffffff - #define FASTFLOAT_32BIT 1 + #define BOOST_CHARCONV_FASTFLOAT_32BIT 1 #elif SIZE_MAX == 0xffffffffffffffff - #define FASTFLOAT_64BIT 1 + #define BOOST_CHARCONV_FASTFLOAT_64BIT 1 #else #error Unknown platform (not 32-bit, not 64-bit?) #endif @@ -70,13 +70,13 @@ using parse_options = parse_options_t; #endif #if defined(_MSC_VER) && !defined(__clang__) -#define FASTFLOAT_VISUAL_STUDIO 1 +#define BOOST_CHARCONV_FASTFLOAT_VISUAL_STUDIO 1 #endif #if defined __BYTE_ORDER__ && defined __ORDER_BIG_ENDIAN__ -#define FASTFLOAT_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) +#define BOOST_CHARCONV_FASTFLOAT_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) #elif defined _WIN32 -#define FASTFLOAT_IS_BIG_ENDIAN 0 +#define BOOST_CHARCONV_FASTFLOAT_IS_BIG_ENDIAN 0 #else #if defined(__APPLE__) || defined(__FreeBSD__) #include @@ -92,42 +92,42 @@ using parse_options = parse_options_t; # #ifndef __BYTE_ORDER__ // safe choice -#define FASTFLOAT_IS_BIG_ENDIAN 0 +#define BOOST_CHARCONV_FASTFLOAT_IS_BIG_ENDIAN 0 #endif # #ifndef __ORDER_LITTLE_ENDIAN__ // safe choice -#define FASTFLOAT_IS_BIG_ENDIAN 0 +#define BOOST_CHARCONV_FASTFLOAT_IS_BIG_ENDIAN 0 #endif # #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define FASTFLOAT_IS_BIG_ENDIAN 0 +#define BOOST_CHARCONV_FASTFLOAT_IS_BIG_ENDIAN 0 #else -#define FASTFLOAT_IS_BIG_ENDIAN 1 +#define BOOST_CHARCONV_FASTFLOAT_IS_BIG_ENDIAN 1 #endif #endif -#ifdef FASTFLOAT_VISUAL_STUDIO +#ifdef BOOST_CHARCONV_FASTFLOAT_VISUAL_STUDIO #define fastfloat_really_inline __forceinline #else #define fastfloat_really_inline inline __attribute__((always_inline)) #endif -#ifndef FASTFLOAT_ASSERT -#define FASTFLOAT_ASSERT(x) { ((void)(x)); } +#ifndef BOOST_CHARCONV_FASTFLOAT_ASSERT +#define BOOST_CHARCONV_FASTFLOAT_ASSERT(x) { ((void)(x)); } #endif -#ifndef FASTFLOAT_DEBUG_ASSERT -#define FASTFLOAT_DEBUG_ASSERT(x) { ((void)(x)); } +#ifndef BOOST_CHARCONV_FASTFLOAT_DEBUG_ASSERT +#define BOOST_CHARCONV_FASTFLOAT_DEBUG_ASSERT(x) { ((void)(x)); } #endif // rust style `try!()` macro, or `?` operator -#define FASTFLOAT_TRY(x) { if (!(x)) return false; } +#define BOOST_CHARCONV_FASTFLOAT_TRY(x) { if (!(x)) return false; } namespace fast_float { fastfloat_really_inline constexpr bool cpp20_and_in_constexpr() { -#if FASTFLOAT_HAS_IS_CONSTANT_EVALUATED +#if BOOST_CHARCONV_FASTFLOAT_HAS_IS_CONSTANT_EVALUATED return std::is_constant_evaluated(); #else return false; @@ -136,7 +136,7 @@ fastfloat_really_inline constexpr bool cpp20_and_in_constexpr() { // Compares two ASCII strings in a case insensitive manner. template -inline FASTFLOAT_CONSTEXPR14 bool +inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 bool fastfloat_strncasecmp(UC const * input1, UC const * input2, size_t length) { char running_diff{0}; for (size_t i = 0; i < length; ++i) { @@ -161,8 +161,8 @@ struct span { return length; } - FASTFLOAT_CONSTEXPR14 const T& operator[](size_t index) const noexcept { - FASTFLOAT_DEBUG_ASSERT(index < length); + BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 const T& operator[](size_t index) const noexcept { + BOOST_CHARCONV_FASTFLOAT_DEBUG_ASSERT(index < length); return ptr[index]; } }; @@ -189,13 +189,13 @@ int leading_zeroes_generic(uint64_t input_num, int last_bit = 0) { } /* result might be undefined when input_num is zero */ -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 int leading_zeroes(uint64_t input_num) { assert(input_num > 0); if (cpp20_and_in_constexpr()) { return leading_zeroes_generic(input_num); } -#ifdef FASTFLOAT_VISUAL_STUDIO +#ifdef BOOST_CHARCONV_FASTFLOAT_VISUAL_STUDIO #if defined(_M_X64) || defined(_M_ARM64) unsigned long leading_zero = 0; // Search the mask data from most significant bit (MSB) @@ -215,7 +215,7 @@ fastfloat_really_inline constexpr uint64_t emulu(uint32_t x, uint32_t y) { return x * (uint64_t)y; } -fastfloat_really_inline FASTFLOAT_CONSTEXPR14 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 uint64_t umul128_generic(uint64_t ab, uint64_t cd, uint64_t *hi) { uint64_t ad = emulu((uint32_t)(ab >> 32), (uint32_t)cd); uint64_t bd = emulu((uint32_t)ab, (uint32_t)cd); @@ -227,21 +227,21 @@ uint64_t umul128_generic(uint64_t ab, uint64_t cd, uint64_t *hi) { return lo; } -#ifdef FASTFLOAT_32BIT +#ifdef BOOST_CHARCONV_FASTFLOAT_32BIT // slow emulation routine for 32-bit #if !defined(__MINGW64__) -fastfloat_really_inline FASTFLOAT_CONSTEXPR14 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 uint64_t _umul128(uint64_t ab, uint64_t cd, uint64_t *hi) { return umul128_generic(ab, cd, hi); } #endif // !__MINGW64__ -#endif // FASTFLOAT_32BIT +#endif // BOOST_CHARCONV_FASTFLOAT_32BIT // compute 64-bit a*b -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 value128 full_multiplication(uint64_t a, uint64_t b) { if (cpp20_and_in_constexpr()) { value128 answer; @@ -254,9 +254,9 @@ value128 full_multiplication(uint64_t a, uint64_t b) { // But MinGW on ARM64 doesn't have native support for 64-bit multiplications answer.high = __umulh(a, b); answer.low = a * b; -#elif defined(FASTFLOAT_32BIT) || (defined(_WIN64) && !defined(__clang__)) +#elif defined(BOOST_CHARCONV_FASTFLOAT_32BIT) || (defined(_WIN64) && !defined(__clang__)) answer.low = _umul128(a, b, &answer.high); // _umul128 not available on ARM64 -#elif defined(FASTFLOAT_64BIT) +#elif defined(BOOST_CHARCONV_FASTFLOAT_64BIT) __uint128_t r = ((__uint128_t)a) * b; answer.low = uint64_t(r); answer.high = uint64_t(r >> 64); @@ -527,20 +527,20 @@ template <> inline constexpr binary_format::equiv_uint } template -fastfloat_really_inline FASTFLOAT_CONSTEXPR20 +fastfloat_really_inline BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 void to_float(bool negative, adjusted_mantissa am, T &value) { using uint = typename binary_format::equiv_uint; uint word = (uint)am.mantissa; word |= uint(am.power2) << binary_format::mantissa_explicit_bits(); word |= uint(negative) << binary_format::sign_index(); -#if FASTFLOAT_HAS_BIT_CAST +#if BOOST_CHARCONV_FASTFLOAT_HAS_BIT_CAST value = std::bit_cast(word); #else ::memcpy(&value, &word, sizeof(T)); #endif } -#ifdef FASTFLOAT_SKIP_WHITE_SPACE // disabled by default +#ifdef BOOST_CHARCONV_FASTFLOAT_SKIP_WHITE_SPACE // disabled by default template struct space_lut { static constexpr bool value[] = { diff --git a/include/boost/charconv/detail/fast_float/parse_number.hpp b/include/boost/charconv/detail/fast_float/parse_number.hpp index 8dabb0e..f89adfa 100644 --- a/include/boost/charconv/detail/fast_float/parse_number.hpp +++ b/include/boost/charconv/detail/fast_float/parse_number.hpp @@ -34,7 +34,7 @@ namespace detail { #endif template -from_chars_result_t FASTFLOAT_CONSTEXPR14 +from_chars_result_t BOOST_CHARCONV_FASTFLOAT_CONSTEXPR14 parse_infnan(UC const * first, UC const * last, T &value) noexcept { from_chars_result_t answer{}; answer.ptr = first; @@ -44,7 +44,7 @@ parse_infnan(UC const * first, UC const * last, T &value) noexcept { minusSign = true; ++first; } -#ifdef FASTFLOAT_ALLOWS_LEADING_PLUS // disabled by default +#ifdef BOOST_CHARCONV_FASTFLOAT_ALLOWS_LEADING_PLUS // disabled by default if (*first == UC('+')) { ++first; } @@ -127,7 +127,7 @@ fastfloat_really_inline bool rounds_to_nearest() noexcept { // // Note: This may fail to be accurate if fast-math has been // enabled, as rounding conventions may not apply. - #ifdef FASTFLOAT_VISUAL_STUDIO + #ifdef BOOST_CHARCONV_FASTFLOAT_VISUAL_STUDIO # pragma warning(push) // todo: is there a VS warning? // see https://stackoverflow.com/questions/46079446/is-there-a-warning-for-floating-point-equality-checking-in-visual-studio-2013 @@ -139,7 +139,7 @@ fastfloat_really_inline bool rounds_to_nearest() noexcept { # pragma GCC diagnostic ignored "-Wfloat-equal" #endif return (fmini + 1.0f == 1.0f - fmini); - #ifdef FASTFLOAT_VISUAL_STUDIO + #ifdef BOOST_CHARCONV_FASTFLOAT_VISUAL_STUDIO # pragma warning(pop) #elif defined(__clang__) # pragma clang diagnostic pop @@ -151,14 +151,14 @@ fastfloat_really_inline bool rounds_to_nearest() noexcept { } // namespace detail template -FASTFLOAT_CONSTEXPR20 +BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 from_chars_result_t from_chars(UC const * first, UC const * last, T &value, chars_format fmt /*= chars_format::general*/) noexcept { return from_chars_advanced(first, last, value, parse_options_t{fmt}); } template -FASTFLOAT_CONSTEXPR20 +BOOST_CHARCONV_FASTFLOAT_CONSTEXPR20 from_chars_result_t from_chars_advanced(UC const * first, UC const * last, T &value, parse_options_t options) noexcept { @@ -169,7 +169,7 @@ from_chars_result_t from_chars_advanced(UC const * first, UC const * last, std::is_same::value , "only char, wchar_t, char16_t and char32_t are supported"); from_chars_result_t answer; -#ifdef FASTFLOAT_SKIP_WHITE_SPACE // disabled by default +#ifdef BOOST_CHARCONV_FASTFLOAT_SKIP_WHITE_SPACE // disabled by default while ((first != last) && fast_float::is_space(uint8_t(*first))) { first++; } diff --git a/include/boost/charconv/detail/significand_tables.hpp b/include/boost/charconv/detail/significand_tables.hpp index 54b3a4d..f9d3f09 100644 --- a/include/boost/charconv/detail/significand_tables.hpp +++ b/include/boost/charconv/detail/significand_tables.hpp @@ -15,8 +15,8 @@ namespace boost { namespace charconv { namespace detail { // The significands of powers of ten from -308 to 308, extended out to sixty four // bits. The array contains the powers of ten approximated - // as a 64-bit significand. It goes from 10^FASTFLOAT_SMALLEST_POWER to - // 10^FASTFLOAT_LARGEST_POWER (inclusively). + // as a 64-bit significand. It goes from 10^BOOST_CHARCONV_FASTFLOAT_SMALLEST_POWER to + // 10^BOOST_CHARCONV_FASTFLOAT_LARGEST_POWER (inclusively). // The significand is truncated, and never rounded up. // Uses about 5KB. static constexpr std::uint64_t significand_64[] = {