koffi 0.9.1 → 0.9.2

package/vendor/dragonbox/source/dragonbox_to_chars.cpp

@@ -0,0 +1,303 @@
+// Copyright 2020-2022 Junekey Jeon
+//
+// The contents of this file may be used under the terms of
+// the Apache License v2.0 with LLVM Exceptions.
+//
+//    (See accompanying file LICENSE-Apache or copy at
+//     https://llvm.org/foundation/relicensing/LICENSE.txt)
+//
+// Alternatively, the contents of this file may be used under the terms of
+// the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE-Boost or copy at
+//     https://www.boost.org/LICENSE_1_0.txt)
+//
+// Unless required by applicable law or agreed to in writing, this software
+// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.
+
+
+#include "dragonbox/dragonbox_to_chars.h"
+
+#if defined(__GNUC__) || defined(__clang__)
+    #define JKJ_FORCEINLINE inline __attribute__((always_inline))
+#elif defined(_MSC_VER)
+    #define JKJ_FORCEINLINE __forceinline
+#else
+    #define JKJ_FORCEINLINE inline
+#endif
+
+namespace jkj::dragonbox {
+    namespace to_chars_detail {
+        // These "//"'s are to prevent clang-format to ruin this nice alignment.
+        // Thanks to reddit user u/mcmcc:
+        // https://www.reddit.com/r/cpp/comments/so3wx9/dragonbox_110_is_released_a_fast_floattostring/hw8z26r/?context=3
+        static constexpr char radix_100_table[] = {
+            '0', '0', '0', '1', '0', '2', '0', '3', '0', '4', //
+            '0', '5', '0', '6', '0', '7', '0', '8', '0', '9', //
+            '1', '0', '1', '1', '1', '2', '1', '3', '1', '4', //
+            '1', '5', '1', '6', '1', '7', '1', '8', '1', '9', //
+            '2', '0', '2', '1', '2', '2', '2', '3', '2', '4', //
+            '2', '5', '2', '6', '2', '7', '2', '8', '2', '9', //
+            '3', '0', '3', '1', '3', '2', '3', '3', '3', '4', //
+            '3', '5', '3', '6', '3', '7', '3', '8', '3', '9', //
+            '4', '0', '4', '1', '4', '2', '4', '3', '4', '4', //
+            '4', '5', '4', '6', '4', '7', '4', '8', '4', '9', //
+            '5', '0', '5', '1', '5', '2', '5', '3', '5', '4', //
+            '5', '5', '5', '6', '5', '7', '5', '8', '5', '9', //
+            '6', '0', '6', '1', '6', '2', '6', '3', '6', '4', //
+            '6', '5', '6', '6', '6', '7', '6', '8', '6', '9', //
+            '7', '0', '7', '1', '7', '2', '7', '3', '7', '4', //
+            '7', '5', '7', '6', '7', '7', '7', '8', '7', '9', //
+            '8', '0', '8', '1', '8', '2', '8', '3', '8', '4', //
+            '8', '5', '8', '6', '8', '7', '8', '8', '8', '9', //
+            '9', '0', '9', '1', '9', '2', '9', '3', '9', '4', //
+            '9', '5', '9', '6', '9', '7', '9', '8', '9', '9'  //
+        };
+
+        // These digit generation routines are inspired by James Anhalt's itoa algorithm:
+        // https://github.com/jeaiii/itoa
+        // The main idea is for given n, find y such that floor(10^k * y / 2^32) = n holds,
+        // where k is an appropriate integer depending on the length of n.
+        // For example, if n = 1234567, we set k = 6. In this case, we have
+        // floor(y / 2^32) = 1,
+        // floor(10^2 * ((10^0 * y) mod 2^32) / 2^32) = 23,
+        // floor(10^2 * ((10^2 * y) mod 2^32) / 2^32) = 45, and
+        // floor(10^2 * ((10^4 * y) mod 2^32) / 2^32) = 67.
+        // See https://jk-jeon.github.io/posts/2022/02/jeaiii-algorithm/ for more explanation.
+
+        JKJ_FORCEINLINE static void print_9_digits(std::uint32_t s32, int& exponent,
+                                                   char*& buffer) noexcept {
+            if (s32 < 100) {
+                if (s32 < 10) {
+                    // 1 digit.
+                    buffer[0] = char('0' + s32);
+                    buffer += 1;
+                }
+                else {
+                    // 2 digits.
+                    buffer[0] = radix_100_table[int(s32) * 2];
+                    buffer[1] = '.';
+                    buffer[2] = radix_100_table[int(s32) * 2 + 1];
+                    buffer += 3;
+                    exponent += 1;
+                }
+            }
+            else {
+                if (s32 < 100'0000) {
+                    if (s32 < 1'0000) {
+                        // 3 or 4 digits.
+                        // 42949673 = ceil(2^32 / 100)
+                        auto prod = s32 * std::uint64_t(42949673);
+                        auto two_digits = int(prod >> 32);
+
+                        // 3 digits.
+                        if (two_digits < 10) {
+                            buffer[0] = char(two_digits + '0');
+                            buffer[1] = '.';
+                            exponent += 2;
+                            prod = std::uint32_t(prod) * std::uint64_t(100);
+                            std::memcpy(buffer + 2, radix_100_table + int(prod >> 32) * 2, 2);
+                            buffer += 4;
+                        }
+                        // 4 digits.
+                        else {
+                            buffer[0] = radix_100_table[two_digits * 2];
+                            buffer[1] = '.';
+                            buffer[2] = radix_100_table[two_digits * 2 + 1];
+                            exponent += 3;
+                            prod = std::uint32_t(prod) * std::uint64_t(100);
+                            std::memcpy(buffer + 3, radix_100_table + int(prod >> 32) * 2, 2);
+                            buffer += 5;
+                        }
+                    }
+                    else {
+                        // 5 or 6 digits.
+                        // 429497 = ceil(2^32 / 1'0000)
+                        auto prod = s32 * std::uint64_t(429497);
+                        auto two_digits = int(prod >> 32);
+
+                        // 5 digits.
+                        if (two_digits < 10) {
+                            buffer[0] = char(two_digits + '0');
+                            buffer[1] = '.';
+                            exponent += 4;
+                            prod = std::uint32_t(prod) * std::uint64_t(100);
+                            std::memcpy(buffer + 2, radix_100_table + int(prod >> 32) * 2, 2);
+                            prod = std::uint32_t(prod) * std::uint64_t(100);
+                            std::memcpy(buffer + 4, radix_100_table + int(prod >> 32) * 2, 2);
+                            buffer += 6;
+                        }
+                        // 6 digits.
+                        else {
+                            buffer[0] = radix_100_table[two_digits * 2];
+                            buffer[1] = '.';
+                            buffer[2] = radix_100_table[two_digits * 2 + 1];
+                            exponent += 5;
+                            prod = std::uint32_t(prod) * std::uint64_t(100);
+                            std::memcpy(buffer + 3, radix_100_table + int(prod >> 32) * 2, 2);
+                            prod = std::uint32_t(prod) * std::uint64_t(100);
+                            std::memcpy(buffer + 5, radix_100_table + int(prod >> 32) * 2, 2);
+                            buffer += 7;
+                        }
+                    }
+                }
+                else {
+                    if (s32 < 1'0000'0000) {
+                        // 7 or 8 digits.
+                        // 281474978 = ceil(2^48 / 100'0000) + 1
+                        auto prod = s32 * std::uint64_t(281474978);
+                        prod >>= 16;
+                        auto two_digits = int(prod >> 32);
+
+                        // 7 digits.
+                        if (two_digits < 10) {
+                            buffer[0] = char(two_digits + '0');
+                            buffer[1] = '.';
+                            exponent += 6;
+                            prod = std::uint32_t(prod) * std::uint64_t(100);
+                            std::memcpy(buffer + 2, radix_100_table + int(prod >> 32) * 2, 2);
+                            prod = std::uint32_t(prod) * std::uint64_t(100);
+                            std::memcpy(buffer + 4, radix_100_table + int(prod >> 32) * 2, 2);
+                            prod = std::uint32_t(prod) * std::uint64_t(100);
+                            std::memcpy(buffer + 6, radix_100_table + int(prod >> 32) * 2, 2);
+                            buffer += 8;
+                        }
+                        // 8 digits.
+                        else {
+                            buffer[0] = radix_100_table[two_digits * 2];
+                            buffer[1] = '.';
+                            buffer[2] = radix_100_table[two_digits * 2 + 1];
+                            exponent += 7;
+                            prod = std::uint32_t(prod) * std::uint64_t(100);
+                            std::memcpy(buffer + 3, radix_100_table + int(prod >> 32) * 2, 2);
+                            prod = std::uint32_t(prod) * std::uint64_t(100);
+                            std::memcpy(buffer + 5, radix_100_table + int(prod >> 32) * 2, 2);
+                            prod = std::uint32_t(prod) * std::uint64_t(100);
+                            std::memcpy(buffer + 7, radix_100_table + int(prod >> 32) * 2, 2);
+                            buffer += 9;
+                        }
+                    }
+                    else {
+                        // 9 digits.
+                        // 1441151882 = ceil(2^57 / 1'0000'0000) + 1
+                        auto prod = s32 * std::uint64_t(1441151882);
+                        prod >>= 25;
+                        buffer[0] = char(int(prod >> 32) + '0');
+                        buffer[1] = '.';
+                        exponent += 8;
+
+                        prod = std::uint32_t(prod) * std::uint64_t(100);
+                        std::memcpy(buffer + 2, radix_100_table + int(prod >> 32) * 2, 2);
+                        prod = std::uint32_t(prod) * std::uint64_t(100);
+                        std::memcpy(buffer + 4, radix_100_table + int(prod >> 32) * 2, 2);
+                        prod = std::uint32_t(prod) * std::uint64_t(100);
+                        std::memcpy(buffer + 6, radix_100_table + int(prod >> 32) * 2, 2);
+                        prod = std::uint32_t(prod) * std::uint64_t(100);
+                        std::memcpy(buffer + 8, radix_100_table + int(prod >> 32) * 2, 2);
+                        buffer += 10;
+                    }
+                }
+            }
+        }
+
+        template <>
+        char* to_chars<float, default_float_traits<float>>(std::uint32_t s32, int exponent,
+                                                           char* buffer) noexcept {
+            // Print significand.
+            print_9_digits(s32, exponent, buffer);
+
+            // Print exponent and return
+            if (exponent < 0) {
+                std::memcpy(buffer, "E-", 2);
+                buffer += 2;
+                exponent = -exponent;
+            }
+            else {
+                buffer[0] = 'E';
+                buffer += 1;
+            }
+
+            if (exponent >= 10) {
+                std::memcpy(buffer, &radix_100_table[exponent * 2], 2);
+                buffer += 2;
+            }
+            else {
+                buffer[0] = (char)('0' + exponent);
+                buffer += 1;
+            }
+
+            return buffer;
+        }
+
+        template <>
+        char* to_chars<double, default_float_traits<double>>(std::uint64_t const significand,
+                                                             int exponent, char* buffer) noexcept {
+            std::uint32_t first_block, second_block;
+            bool have_second_block;
+
+            if (significand < 10'0000'0000) {
+                first_block = std::uint32_t(significand);
+                have_second_block = false;
+            }
+            else {
+                first_block = std::uint32_t(significand / 1'0000'0000);
+                second_block = std::uint32_t(significand) - first_block * 1'0000'0000;
+                have_second_block = true;
+            }
+
+            // Print the first block of significand.
+            print_9_digits(first_block, exponent, buffer);
+
+            // Print second block if necessary.
+            if (have_second_block) {
+                // 281474978 = ceil(2^48 / 100'0000) + 1
+                auto prod = second_block * std::uint64_t(281474978);
+                prod >>= 16;
+                prod += 1;
+                exponent += 8;
+
+                std::memcpy(buffer + 0, radix_100_table + int(prod >> 32) * 2, 2);
+                prod = std::uint32_t(prod) * std::uint64_t(100);
+                std::memcpy(buffer + 2, radix_100_table + int(prod >> 32) * 2, 2);
+                prod = std::uint32_t(prod) * std::uint64_t(100);
+                std::memcpy(buffer + 4, radix_100_table + int(prod >> 32) * 2, 2);
+                prod = std::uint32_t(prod) * std::uint64_t(100);
+                std::memcpy(buffer + 6, radix_100_table + int(prod >> 32) * 2, 2);
+                buffer += 8;
+            }
+
+            // Print exponent and return
+            if (exponent < 0) {
+                std::memcpy(buffer, "E-", 2);
+                buffer += 2;
+                exponent = -exponent;
+            }
+            else {
+                buffer[0] = 'E';
+                buffer += 1;
+            }
+
+            if (exponent >= 100) {
+                // d1 = exponent / 10; d2 = exponent % 10;
+                // 6554 = ceil(2^16 / 10)
+                auto prod = std::uint32_t(exponent) * std::uint32_t(6554);
+                auto d1 = prod >> 16;
+                prod = std::uint16_t(prod) * std::uint32_t(5); // * 10
+                auto d2 = prod >> 15;                          // >> 16
+                std::memcpy(buffer, &radix_100_table[d1 * 2], 2);
+                buffer[2] = char('0' + d2);
+                buffer += 3;
+            }
+            else if (exponent >= 10) {
+                std::memcpy(buffer, &radix_100_table[exponent * 2], 2);
+                buffer += 2;
+            }
+            else {
+                buffer[0] = char('0' + exponent);
+                buffer += 1;
+            }
+
+            return buffer;
+        }
+    }
+}

package/vendor/dragonbox/subproject/3rdparty/grisu_exact/CMakeLists.txt

@@ -0,0 +1,24 @@
+cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
+
+project(grisu_exact LANGUAGES CXX)
+
+add_library(grisu_exact STATIC fp_to_chars.h fp_to_chars.cpp grisu_exact.h)
+add_library(grisu_exact::grisu_exact ALIAS grisu_exact)
+
+target_compile_features(grisu_exact PUBLIC cxx_std_17)
+
+target_include_directories(grisu_exact
+        PUBLIC
+        $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>)
+
+# ---- MSVC Specifics ----
+if (MSVC)
+    # No need to not generate PDB
+    # /permissive- should be the default
+    # The compilation will fail without /experimental:newLambdaProcessor
+    # See also https://gitlab.kitware.com/cmake/cmake/-/issues/16478
+    target_compile_options(grisu_exact PUBLIC
+              /Zi /permissive-
+              $<$<NOT:$<CXX_COMPILER_ID:Clang>>:/experimental:newLambdaProcessor>
+              $<$<CONFIG:Release>:/GL>)
+endif()

package/vendor/dragonbox/subproject/3rdparty/grisu_exact/fp_to_chars.cpp

@@ -0,0 +1,238 @@
+// The contents of this file is based on contents of:
+//
+// https://github.com/ulfjack/ryu/blob/master/ryu/common.h,
+// https://github.com/ulfjack/ryu/blob/master/ryu/d2s.c, and
+// https://github.com/ulfjack/ryu/blob/master/ryu/f2s.c,
+//
+// which are distributed under the following terms:
+//--------------------------------------------------------------------------------
+// Copyright 2018 Ulf Adams
+//
+// The contents of this file may be used under the terms of the Apache License,
+// Version 2.0.
+//
+//    (See accompanying file LICENSE-Apache or copy at
+//     http://www.apache.org/licenses/LICENSE-2.0)
+//
+// Alternatively, the contents of this file may be used under the terms of
+// the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE-Boost or copy at
+//     https://www.boost.org/LICENSE_1_0.txt)
+//
+// Unless required by applicable law or agreed to in writing, this software
+// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.
+//--------------------------------------------------------------------------------
+// Modifications Copyright 2020 Junekey Jeon
+//
+// Following modifications were made to the original contents:
+//  - Put everything inside the namespace jkj::fp_to_chars_detail
+//  - Combined decimalLength9 (from common.h) and decimalLength17 (from d2s.c)
+//    into a single template function decimal_length
+//  - Combined to_chars (from f2s.c) and to_chars (from d2s.c) into a
+//    single template function fp_to_chars_impl
+//  - Removed index counting statements; replaced them with pointer increments
+//  - Removed usages of DIGIT_TABLE; replaced them with radix_100_table
+//
+//  These modifications, together with other contents of this file may be used
+//  under the same terms as the original contents.
+
+
+#include "fp_to_chars.h"
+
+namespace jkj {
+	namespace fp_to_chars_detail {
+		static constexpr char radix_100_table[] = {
+			'0', '0', '0', '1', '0', '2', '0', '3', '0', '4',
+			'0', '5', '0', '6', '0', '7', '0', '8', '0', '9',
+			'1', '0', '1', '1', '1', '2', '1', '3', '1', '4',
+			'1', '5', '1', '6', '1', '7', '1', '8', '1', '9',
+			'2', '0', '2', '1', '2', '2', '2', '3', '2', '4',
+			'2', '5', '2', '6', '2', '7', '2', '8', '2', '9',
+			'3', '0', '3', '1', '3', '2', '3', '3', '3', '4',
+			'3', '5', '3', '6', '3', '7', '3', '8', '3', '9',
+			'4', '0', '4', '1', '4', '2', '4', '3', '4', '4',
+			'4', '5', '4', '6', '4', '7', '4', '8', '4', '9',
+			'5', '0', '5', '1', '5', '2', '5', '3', '5', '4',
+			'5', '5', '5', '6', '5', '7', '5', '8', '5', '9',
+			'6', '0', '6', '1', '6', '2', '6', '3', '6', '4',
+			'6', '5', '6', '6', '6', '7', '6', '8', '6', '9',
+			'7', '0', '7', '1', '7', '2', '7', '3', '7', '4',
+			'7', '5', '7', '6', '7', '7', '7', '8', '7', '9',
+			'8', '0', '8', '1', '8', '2', '8', '3', '8', '4',
+			'8', '5', '8', '6', '8', '7', '8', '8', '8', '9',
+			'9', '0', '9', '1', '9', '2', '9', '3', '9', '4',
+			'9', '5', '9', '6', '9', '7', '9', '8', '9', '9'
+		};
+
+		template <class UInt>
+		static constexpr std::uint32_t decimal_length(UInt const v) {
+			if constexpr (std::is_same_v<UInt, std::uint32_t>) {
+				// Function precondition: v is not a 10-digit number.
+				// (f2s: 9 digits are sufficient for round-tripping.)
+				// (d2fixed: We print 9-digit blocks.)
+				assert(v < 1000000000);
+				if (v >= 100000000) { return 9; }
+				if (v >= 10000000) { return 8; }
+				if (v >= 1000000) { return 7; }
+				if (v >= 100000) { return 6; }
+				if (v >= 10000) { return 5; }
+				if (v >= 1000) { return 4; }
+				if (v >= 100) { return 3; }
+				if (v >= 10) { return 2; }
+				return 1;
+			}
+			else {
+				static_assert(std::is_same_v<UInt, std::uint64_t>);
+				// This is slightly faster than a loop.
+				// The average output length is 16.38 digits, so we check high-to-low.
+				// Function precondition: v is not an 18, 19, or 20-digit number.
+				// (17 digits are sufficient for round-tripping.)
+				assert(v < 100000000000000000L);
+				if (v >= 10000000000000000L) { return 17; }
+				if (v >= 1000000000000000L) { return 16; }
+				if (v >= 100000000000000L) { return 15; }
+				if (v >= 10000000000000L) { return 14; }
+				if (v >= 1000000000000L) { return 13; }
+				if (v >= 100000000000L) { return 12; }
+				if (v >= 10000000000L) { return 11; }
+				if (v >= 1000000000L) { return 10; }
+				if (v >= 100000000L) { return 9; }
+				if (v >= 10000000L) { return 8; }
+				if (v >= 1000000L) { return 7; }
+				if (v >= 100000L) { return 6; }
+				if (v >= 10000L) { return 5; }
+				if (v >= 1000L) { return 4; }
+				if (v >= 100L) { return 3; }
+				if (v >= 10L) { return 2; }
+				return 1;
+			}
+		}
+
+		template <class Float>
+		static char* fp_to_chars_impl(unsigned_fp_t<Float> v, char* buffer)
+		{
+			auto output = v.significand;
+			auto const olength = decimal_length(output);
+
+			// Print the decimal digits.
+			// The following code is equivalent to:
+			// for (uint32_t i = 0; i < olength - 1; ++i) {
+			//   const uint32_t c = output % 10; output /= 10;
+			//   result[index + olength - i] = (char) ('0' + c);
+			// }
+			// result[index] = '0' + output % 10;
+
+			uint32_t i = 0;
+			if constexpr (sizeof(Float) == 8) {
+				// We prefer 32-bit operations, even on 64-bit platforms.
+			// We have at most 17 digits, and uint32_t can store 9 digits.
+			// If output doesn't fit into uint32_t, we cut off 8 digits,
+			// so the rest will fit into uint32_t.
+				if ((output >> 32) != 0) {
+					// Expensive 64-bit division.
+					const uint64_t q = output / 100000000;
+					uint32_t output2 = ((uint32_t)output) - 100000000 * ((uint32_t)q);
+					output = q;
+
+					const uint32_t c = output2 % 10000;
+					output2 /= 10000;
+					const uint32_t d = output2 % 10000;
+					const uint32_t c0 = (c % 100) << 1;
+					const uint32_t c1 = (c / 100) << 1;
+					const uint32_t d0 = (d % 100) << 1;
+					const uint32_t d1 = (d / 100) << 1;
+					memcpy(buffer + olength - i - 1, radix_100_table + c0, 2);
+					memcpy(buffer + olength - i - 3, radix_100_table + c1, 2);
+					memcpy(buffer + olength - i - 5, radix_100_table + d0, 2);
+					memcpy(buffer + olength - i - 7, radix_100_table + d1, 2);
+					i += 8;
+				}
+			}
+
+			auto output2 = (uint32_t)output;
+			while (output2 >= 10000) {
+#ifdef __clang__ // https://bugs.llvm.org/show_bug.cgi?id=38217
+				const uint32_t c = output2 - 10000 * (output2 / 10000);
+#else
+				const uint32_t c = output2 % 10000;
+#endif
+				output2 /= 10000;
+				const uint32_t c0 = (c % 100) << 1;
+				const uint32_t c1 = (c / 100) << 1;
+				memcpy(buffer + olength - i - 1, radix_100_table + c0, 2);
+				memcpy(buffer + olength - i - 3, radix_100_table + c1, 2);
+				i += 4;
+			}
+			if (output2 >= 100) {
+				const uint32_t c = (output2 % 100) << 1;
+				output2 /= 100;
+				memcpy(buffer + olength - i - 1, radix_100_table + c, 2);
+				i += 2;
+			}
+			if (output2 >= 10) {
+				const uint32_t c = output2 << 1;
+				// We can't use memcpy here: the decimal dot goes between these two digits.
+				buffer[olength - i] = radix_100_table[c + 1];
+				buffer[0] = radix_100_table[c];
+			}
+			else {
+				buffer[0] = (char)('0' + output2);
+			}
+
+			// Print decimal point if needed.
+			if (olength > 1) {
+				buffer[1] = '.';
+				buffer += olength + 1;
+			}
+			else {
+				++buffer;
+			}
+
+			// Print the exponent.
+			*buffer = 'E';
+			++buffer;
+			int32_t exp = v.exponent + (int32_t)olength - 1;
+			if (exp < 0) {
+				*buffer = '-';
+				++buffer;
+				exp = -exp;
+			}
+			if constexpr (sizeof(Float) == 8) {
+				if (exp >= 100) {
+					const int32_t c = exp % 10;
+					memcpy(buffer, radix_100_table + 2 * (exp / 10), 2);
+					buffer[2] = (char)('0' + c);
+					buffer += 3;
+				}
+				else if (exp >= 10) {
+					memcpy(buffer, radix_100_table + 2 * exp, 2);
+					buffer += 2;
+				}
+				else {
+					*buffer = (char)('0' + exp);
+					++buffer;
+				}
+			}
+			else {
+				if (exp >= 10) {
+					memcpy(buffer, radix_100_table + 2 * exp, 2);
+					buffer += 2;
+				}
+				else {
+					*buffer = (char)('0' + exp);
+					++buffer;
+				}
+			}
+
+			return buffer;
+		}
+		
+		char* float_to_chars(unsigned_fp_t<float> v, char* buffer) {
+			return fp_to_chars_impl(v, buffer);
+		}
+		char* double_to_chars(unsigned_fp_t<double> v, char* buffer) {
+			return fp_to_chars_impl(v, buffer);
+		}
+	}
+}

package/vendor/dragonbox/subproject/3rdparty/grisu_exact/fp_to_chars.h

@@ -0,0 +1,95 @@
+// Copyright 2020 Junekey Jeon
+//
+// The contents of this file may be used under the terms of
+// the Apache License v2.0 with LLVM Exceptions.
+//
+//    (See accompanying file LICENSE-Apache or copy at
+//     https://llvm.org/foundation/relicensing/LICENSE.txt)
+//
+// Alternatively, the contents of this file may be used under the terms of
+// the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE-Boost or copy at
+//     https://www.boost.org/LICENSE_1_0.txt)
+//
+// Unless required by applicable law or agreed to in writing, this software
+// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.
+
+#ifndef JKJ_FP_TO_CHARS
+#define JKJ_FP_TO_CHARS
+
+#include "grisu_exact.h"
+
+namespace jkj {
+	namespace fp_to_chars_detail {
+		char* float_to_chars(unsigned_fp_t<float> v, char* buffer);
+		char* double_to_chars(unsigned_fp_t<double> v, char* buffer);
+	}
+
+	// Returns the next-to-end position
+	template <class Float,
+		class RoundingMode = grisu_exact_rounding_modes::nearest_to_even,
+		class CorrectRoundingSearch = grisu_exact_correct_rounding::tie_to_even
+	>
+	char* fp_to_chars_n(Float x, char* buffer,
+		RoundingMode&& rounding_mode = {},
+		CorrectRoundingSearch&& crs = {})
+	{
+		auto br = get_bit_representation(x);
+		if (br.is_finite()) {
+			if (br.is_negative()) {
+				*buffer = '-';
+				++buffer;
+			}
+			if (br.is_nonzero()) {
+				if constexpr (sizeof(Float) == 4) {
+					return fp_to_chars_detail::float_to_chars(grisu_exact<false>(x,
+						std::forward<RoundingMode>(rounding_mode),
+						std::forward<CorrectRoundingSearch>(crs)), buffer);
+				}
+				else {
+					return fp_to_chars_detail::double_to_chars(grisu_exact<false>(x,
+						std::forward<RoundingMode>(rounding_mode),
+						std::forward<CorrectRoundingSearch>(crs)), buffer);
+				}
+			}
+			else {
+				std::memcpy(buffer, "0E0", 3);
+				return buffer + 3;
+			}
+		}
+		else {
+			if ((br.f << (grisu_exact_detail::common_info<Float>::exponent_bits + 1)) != 0)
+			{
+				std::memcpy(buffer, "NaN", 3);
+				return buffer + 3;
+			}
+			else {
+				if (br.is_negative()) {
+					*buffer = '-';
+					++buffer;
+				}
+				std::memcpy(buffer, "Infinity", 8);
+				return buffer + 8;
+			}
+		}
+	}
+
+	// Null-terminate and bypass the return value of fp_to_chars_n
+	template <class Float,
+		class RoundingMode = grisu_exact_rounding_modes::nearest_to_even,
+		class CorrectRoundingSearch = grisu_exact_correct_rounding::tie_to_even
+	>
+	char* fp_to_chars(Float x, char* buffer,
+		RoundingMode&& rounding_mode = {},
+		CorrectRoundingSearch&& crs = {})
+	{
+		auto ptr = fp_to_chars_n(x, buffer,
+			std::forward<RoundingMode>(rounding_mode),
+			std::forward<CorrectRoundingSearch>(crs));
+		*ptr = '\0';
+		return ptr;
+	}
+}
+
+#endif