RubyGems - postfinancecheckout-ruby-sdk - Versions diffs - 5.2.0 → 6.0.0 - Mend

postfinancecheckout-ruby-sdk 5.2.0 → 6.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1403) hide show

data/vendor/bundle/ruby/3.3.0/gems/json-2.15.1/ext/json/ext/simd/conf.rb DELETED Viewed

@@ -1,24 +0,0 @@
-case RbConfig::CONFIG['host_cpu']
-when /^(arm|aarch64)/
-  # Try to compile a small program using NEON instructions
-  header, type, init, extra = 'arm_neon.h', 'uint8x16_t', 'vdupq_n_u8(32)', nil
-when /^(x86_64|x64)/
-  header, type, init, extra = 'x86intrin.h', '__m128i', '_mm_set1_epi8(32)', 'if (__builtin_cpu_supports("sse2")) { printf("OK"); }'
-end
-if header
-  if have_header(header) && try_compile(<<~SRC, '-Werror=implicit-function-declaration')
-      #{cpp_include(header)}
-      int main(int argc, char **argv) {
-        #{type} test = #{init};
-        #{extra}
-        if (argc > 100000) printf("%p", &test);
-        return 0;
-      }
-    SRC
-    $defs.push("-DJSON_ENABLE_SIMD")
-  else
-    puts "Disable SIMD"
-  end
-end
-have_header('cpuid.h')

data/vendor/bundle/ruby/3.3.0/gems/json-2.15.1/ext/json/ext/simd/simd.h DELETED Viewed

@@ -1,188 +0,0 @@
-typedef enum {
-    SIMD_NONE,
-    SIMD_NEON,
-    SIMD_SSE2
-} SIMD_Implementation;
-#ifdef JSON_ENABLE_SIMD
-#ifdef __clang__
-# if __has_builtin(__builtin_ctzll)
-#   define HAVE_BUILTIN_CTZLL 1
-# else
-#   define HAVE_BUILTIN_CTZLL 0
-# endif
-#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
-# define HAVE_BUILTIN_CTZLL 1
-#else
-# define HAVE_BUILTIN_CTZLL 0
-#endif
-static inline uint32_t trailing_zeros64(uint64_t input)
-{
-#if HAVE_BUILTIN_CTZLL
-    return __builtin_ctzll(input);
-#else
-    uint32_t trailing_zeros = 0;
-    uint64_t temp = input;
-    while ((temp & 1) == 0 && temp > 0) {
-        trailing_zeros++;
-        temp >>= 1;
-    }
-    return trailing_zeros;
-#endif
-}
-static inline int trailing_zeros(int input)
-{
-#if HAVE_BUILTIN_CTZLL
-    return __builtin_ctz(input);
-#else
-    int trailing_zeros = 0;
-    int temp = input;
-    while ((temp & 1) == 0 && temp > 0) {
-        trailing_zeros++;
-        temp >>= 1;
-    }
-    return trailing_zeros;
-#endif
-}
-#if (defined(__GNUC__ ) || defined(__clang__))
-#define FORCE_INLINE __attribute__((always_inline))
-#else
-#define FORCE_INLINE
-#endif
-#define SIMD_MINIMUM_THRESHOLD 6
-#if defined(__ARM_NEON) || defined(__ARM_NEON__) || defined(__aarch64__) || defined(_M_ARM64)
-#include <arm_neon.h>
-#define FIND_SIMD_IMPLEMENTATION_DEFINED 1
-static inline SIMD_Implementation find_simd_implementation(void)
-{
-    return SIMD_NEON;
-}
-#define HAVE_SIMD 1
-#define HAVE_SIMD_NEON 1
-// See: https://community.arm.com/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/porting-x86-vector-bitmask-optimizations-to-arm-neon
-static inline FORCE_INLINE uint64_t neon_match_mask(uint8x16_t matches)
-{
-    const uint8x8_t res = vshrn_n_u16(vreinterpretq_u16_u8(matches), 4);
-    const uint64_t mask = vget_lane_u64(vreinterpret_u64_u8(res), 0);
-    return mask & 0x8888888888888888ull;
-}
-static inline FORCE_INLINE uint64_t compute_chunk_mask_neon(const char *ptr)
-{
-    uint8x16_t chunk = vld1q_u8((const unsigned char *)ptr);
-    // Trick: c < 32 || c == 34 can be factored as c ^ 2 < 33
-    // https://lemire.me/blog/2025/04/13/detect-control-characters-quotes-and-backslashes-efficiently-using-swar/
-    const uint8x16_t too_low_or_dbl_quote = vcltq_u8(veorq_u8(chunk, vdupq_n_u8(2)), vdupq_n_u8(33));
-    uint8x16_t has_backslash = vceqq_u8(chunk, vdupq_n_u8('\\'));
-    uint8x16_t needs_escape  = vorrq_u8(too_low_or_dbl_quote, has_backslash);
-    return neon_match_mask(needs_escape);
-}
-static inline FORCE_INLINE int string_scan_simd_neon(const char **ptr, const char *end, uint64_t *mask)
-{
-    while (*ptr + sizeof(uint8x16_t) <= end) {
-        uint64_t chunk_mask = compute_chunk_mask_neon(*ptr);
-        if (chunk_mask) {
-            *mask = chunk_mask;
-            return 1;
-        }
-        *ptr += sizeof(uint8x16_t);
-    }
-    return 0;
-}
-static inline uint8x16x4_t load_uint8x16_4(const unsigned char *table)
-{
-    uint8x16x4_t tab;
-    tab.val[0] = vld1q_u8(table);
-    tab.val[1] = vld1q_u8(table+16);
-    tab.val[2] = vld1q_u8(table+32);
-    tab.val[3] = vld1q_u8(table+48);
-    return tab;
-}
-#endif /* ARM Neon Support.*/
-#if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_X64) || defined(_M_AMD64)
-#ifdef HAVE_X86INTRIN_H
-#include <x86intrin.h>
-#define HAVE_SIMD 1
-#define HAVE_SIMD_SSE2 1
-#ifdef HAVE_CPUID_H
-#define FIND_SIMD_IMPLEMENTATION_DEFINED 1
-#if defined(__clang__) || defined(__GNUC__)
-#define TARGET_SSE2 __attribute__((target("sse2")))
-#else
-#define TARGET_SSE2
-#endif
-#define _mm_cmpge_epu8(a, b) _mm_cmpeq_epi8(_mm_max_epu8(a, b), a)
-#define _mm_cmple_epu8(a, b) _mm_cmpge_epu8(b, a)
-#define _mm_cmpgt_epu8(a, b) _mm_xor_si128(_mm_cmple_epu8(a, b), _mm_set1_epi8(-1))
-#define _mm_cmplt_epu8(a, b) _mm_cmpgt_epu8(b, a)
-static inline TARGET_SSE2 FORCE_INLINE int compute_chunk_mask_sse2(const char *ptr)
-{
-    __m128i chunk         = _mm_loadu_si128((__m128i const*)ptr);
-    // Trick: c < 32 || c == 34 can be factored as c ^ 2 < 33
-    // https://lemire.me/blog/2025/04/13/detect-control-characters-quotes-and-backslashes-efficiently-using-swar/
-    __m128i too_low_or_dbl_quote = _mm_cmplt_epu8(_mm_xor_si128(chunk, _mm_set1_epi8(2)), _mm_set1_epi8(33));
-    __m128i has_backslash = _mm_cmpeq_epi8(chunk, _mm_set1_epi8('\\'));
-    __m128i needs_escape  = _mm_or_si128(too_low_or_dbl_quote, has_backslash);
-    return _mm_movemask_epi8(needs_escape);
-}
-static inline TARGET_SSE2 FORCE_INLINE int string_scan_simd_sse2(const char **ptr, const char *end, int *mask)
-{
-    while (*ptr + sizeof(__m128i) <= end) {
-        int chunk_mask = compute_chunk_mask_sse2(*ptr);
-        if (chunk_mask) {
-            *mask = chunk_mask;
-            return 1;
-        }
-        *ptr += sizeof(__m128i);
-    }
-    return 0;
-}
-#include <cpuid.h>
-#endif /* HAVE_CPUID_H */
-static inline SIMD_Implementation find_simd_implementation(void)
-{
-    // TODO Revisit. I think the SSE version now only uses SSE2 instructions.
-    if (__builtin_cpu_supports("sse2")) {
-        return SIMD_SSE2;
-    }
-    return SIMD_NONE;
-}
-#endif /* HAVE_X86INTRIN_H */
-#endif /* X86_64 Support */
-#endif /* JSON_ENABLE_SIMD */
-#ifndef FIND_SIMD_IMPLEMENTATION_DEFINED
-static inline SIMD_Implementation find_simd_implementation(void)
-{
-    return SIMD_NONE;
-}
-#endif

data/vendor/bundle/ruby/3.3.0/gems/json-2.15.1/ext/json/ext/vendor/fpconv.c DELETED Viewed

@@ -1,480 +0,0 @@
-// Boost Software License - Version 1.0 - August 17th, 2003
-//
-// Permission is hereby granted, free of charge, to any person or organization
-// obtaining a copy of the software and accompanying documentation covered by
-// this license (the "Software") to use, reproduce, display, distribute,
-// execute, and transmit the Software, and to prepare derivative works of the
-// Software, and to permit third-parties to whom the Software is furnished to
-// do so, all subject to the following:
-//
-// The copyright notices in the Software and this entire statement, including
-// the above license grant, this restriction and the following disclaimer,
-// must be included in all copies of the Software, in whole or in part, and
-// all derivative works of the Software, unless such copies or derivative
-// works are solely in the form of machine-executable object code generated by
-// a source language processor.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-// DEALINGS IN THE SOFTWARE.
-// The contents of this file is extracted from https://github.com/night-shift/fpconv
-// It was slightly modified to append ".0" to plain floats, for use with the https://github.com/ruby/json package.
-#include <stdbool.h>
-#include <string.h>
-#include <stdint.h>
-#ifdef JSON_DEBUG
-#include <assert.h>
-#endif
-#define npowers     87
-#define steppowers  8
-#define firstpower -348 /* 10 ^ -348 */
-#define expmax     -32
-#define expmin     -60
-typedef struct Fp {
-    uint64_t frac;
-    int exp;
-} Fp;
-static const Fp powers_ten[] = {
-    { 18054884314459144840U, -1220 }, { 13451937075301367670U, -1193 },
-    { 10022474136428063862U, -1166 }, { 14934650266808366570U, -1140 },
-    { 11127181549972568877U, -1113 }, { 16580792590934885855U, -1087 },
-    { 12353653155963782858U, -1060 }, { 18408377700990114895U, -1034 },
-    { 13715310171984221708U, -1007 }, { 10218702384817765436U, -980 },
-    { 15227053142812498563U, -954 },  { 11345038669416679861U, -927 },
-    { 16905424996341287883U, -901 },  { 12595523146049147757U, -874 },
-    { 9384396036005875287U,  -847 },  { 13983839803942852151U, -821 },
-    { 10418772551374772303U, -794 },  { 15525180923007089351U, -768 },
-    { 11567161174868858868U, -741 },  { 17236413322193710309U, -715 },
-    { 12842128665889583758U, -688 },  { 9568131466127621947U,  -661 },
-    { 14257626930069360058U, -635 },  { 10622759856335341974U, -608 },
-    { 15829145694278690180U, -582 },  { 11793632577567316726U, -555 },
-    { 17573882009934360870U, -529 },  { 13093562431584567480U, -502 },
-    { 9755464219737475723U,  -475 },  { 14536774485912137811U, -449 },
-    { 10830740992659433045U, -422 },  { 16139061738043178685U, -396 },
-    { 12024538023802026127U, -369 },  { 17917957937422433684U, -343 },
-    { 13349918974505688015U, -316 },  { 9946464728195732843U,  -289 },
-    { 14821387422376473014U, -263 },  { 11042794154864902060U, -236 },
-    { 16455045573212060422U, -210 },  { 12259964326927110867U, -183 },
-    { 18268770466636286478U, -157 },  { 13611294676837538539U, -130 },
-    { 10141204801825835212U, -103 },  { 15111572745182864684U, -77 },
-    { 11258999068426240000U, -50 },   { 16777216000000000000U, -24 },
-    { 12500000000000000000U,   3 },   { 9313225746154785156U,   30 },
-    { 13877787807814456755U,  56 },   { 10339757656912845936U,  83 },
-    { 15407439555097886824U, 109 },   { 11479437019748901445U, 136 },
-    { 17105694144590052135U, 162 },   { 12744735289059618216U, 189 },
-    { 9495567745759798747U,  216 },   { 14149498560666738074U, 242 },
-    { 10542197943230523224U, 269 },   { 15709099088952724970U, 295 },
-    { 11704190886730495818U, 322 },   { 17440603504673385349U, 348 },
-    { 12994262207056124023U, 375 },   { 9681479787123295682U,  402 },
-    { 14426529090290212157U, 428 },   { 10748601772107342003U, 455 },
-    { 16016664761464807395U, 481 },   { 11933345169920330789U, 508 },
-    { 17782069995880619868U, 534 },   { 13248674568444952270U, 561 },
-    { 9871031767461413346U,  588 },   { 14708983551653345445U, 614 },
-    { 10959046745042015199U, 641 },   { 16330252207878254650U, 667 },
-    { 12166986024289022870U, 694 },   { 18130221999122236476U, 720 },
-    { 13508068024458167312U, 747 },   { 10064294952495520794U, 774 },
-    { 14996968138956309548U, 800 },   { 11173611982879273257U, 827 },
-    { 16649979327439178909U, 853 },   { 12405201291620119593U, 880 },
-    { 9242595204427927429U,  907 },   { 13772540099066387757U, 933 },
-    { 10261342003245940623U, 960 },   { 15290591125556738113U, 986 },
-    { 11392378155556871081U, 1013 },  { 16975966327722178521U, 1039 },
-    { 12648080533535911531U, 1066 }
-};
-static Fp find_cachedpow10(int exp, int* k)
-{
-    const double one_log_ten = 0.30102999566398114;
-    int approx = (int)(-(exp + npowers) * one_log_ten);
-    int idx = (approx - firstpower) / steppowers;
-    while(1) {
-        int current = exp + powers_ten[idx].exp + 64;
-        if(current < expmin) {
-            idx++;
-            continue;
-        }
-        if(current > expmax) {
-            idx--;
-            continue;
-        }
-        *k = (firstpower + idx * steppowers);
-        return powers_ten[idx];
-    }
-}
-#define fracmask  0x000FFFFFFFFFFFFFU
-#define expmask   0x7FF0000000000000U
-#define hiddenbit 0x0010000000000000U
-#define signmask  0x8000000000000000U
-#define expbias   (1023 + 52)
-#define absv(n) ((n) < 0 ? -(n) : (n))
-#define minv(a, b) ((a) < (b) ? (a) : (b))
-static const uint64_t tens[] = {
-    10000000000000000000U, 1000000000000000000U, 100000000000000000U,
-    10000000000000000U, 1000000000000000U, 100000000000000U,
-    10000000000000U, 1000000000000U, 100000000000U,
-    10000000000U, 1000000000U, 100000000U,
-    10000000U, 1000000U, 100000U,
-    10000U, 1000U, 100U,
-    10U, 1U
-};
-static inline uint64_t get_dbits(double d)
-{
-    union {
-        double   dbl;
-        uint64_t i;
-    } dbl_bits = { d };
-    return dbl_bits.i;
-}
-static Fp build_fp(double d)
-{
-    uint64_t bits = get_dbits(d);
-    Fp fp;
-    fp.frac = bits & fracmask;
-    fp.exp = (bits & expmask) >> 52;
-    if(fp.exp) {
-        fp.frac += hiddenbit;
-        fp.exp -= expbias;
-    } else {
-        fp.exp = -expbias + 1;
-    }
-    return fp;
-}
-static void normalize(Fp* fp)
-{
-    while ((fp->frac & hiddenbit) == 0) {
-        fp->frac <<= 1;
-        fp->exp--;
-    }
-    int shift = 64 - 52 - 1;
-    fp->frac <<= shift;
-    fp->exp -= shift;
-}
-static void get_normalized_boundaries(Fp* fp, Fp* lower, Fp* upper)
-{
-    upper->frac = (fp->frac << 1) + 1;
-    upper->exp  = fp->exp - 1;
-    while ((upper->frac & (hiddenbit << 1)) == 0) {
-        upper->frac <<= 1;
-        upper->exp--;
-    }
-    int u_shift = 64 - 52 - 2;
-    upper->frac <<= u_shift;
-    upper->exp = upper->exp - u_shift;
-    int l_shift = fp->frac == hiddenbit ? 2 : 1;
-    lower->frac = (fp->frac << l_shift) - 1;
-    lower->exp = fp->exp - l_shift;
-    lower->frac <<= lower->exp - upper->exp;
-    lower->exp = upper->exp;
-}
-static Fp multiply(Fp* a, Fp* b)
-{
-    const uint64_t lomask = 0x00000000FFFFFFFF;
-    uint64_t ah_bl = (a->frac >> 32)    * (b->frac & lomask);
-    uint64_t al_bh = (a->frac & lomask) * (b->frac >> 32);
-    uint64_t al_bl = (a->frac & lomask) * (b->frac & lomask);
-    uint64_t ah_bh = (a->frac >> 32)    * (b->frac >> 32);
-    uint64_t tmp = (ah_bl & lomask) + (al_bh & lomask) + (al_bl >> 32);
-    /* round up */
-    tmp += 1U << 31;
-    Fp fp = {
-        ah_bh + (ah_bl >> 32) + (al_bh >> 32) + (tmp >> 32),
-        a->exp + b->exp + 64
-    };
-    return fp;
-}
-static void round_digit(char* digits, int ndigits, uint64_t delta, uint64_t rem, uint64_t kappa, uint64_t frac)
-{
-    while (rem < frac && delta - rem >= kappa &&
-           (rem + kappa < frac || frac - rem > rem + kappa - frac)) {
-        digits[ndigits - 1]--;
-        rem += kappa;
-    }
-}
-static int generate_digits(Fp* fp, Fp* upper, Fp* lower, char* digits, int* K)
-{
-    uint64_t wfrac = upper->frac - fp->frac;
-    uint64_t delta = upper->frac - lower->frac;
-    Fp one;
-    one.frac = 1ULL << -upper->exp;
-    one.exp  = upper->exp;
-    uint64_t part1 = upper->frac >> -one.exp;
-    uint64_t part2 = upper->frac & (one.frac - 1);
-    int idx = 0, kappa = 10;
-    const uint64_t* divp;
-    /* 1000000000 */
-    for(divp = tens + 10; kappa > 0; divp++) {
-        uint64_t div = *divp;
-        unsigned digit = (unsigned) (part1 / div);
-        if (digit || idx) {
-            digits[idx++] = digit + '0';
-        }
-        part1 -= digit * div;
-        kappa--;
-        uint64_t tmp = (part1 <<-one.exp) + part2;
-        if (tmp <= delta) {
-            *K += kappa;
-            round_digit(digits, idx, delta, tmp, div << -one.exp, wfrac);
-            return idx;
-        }
-    }
-    /* 10 */
-    const uint64_t* unit = tens + 18;
-    while(true) {
-        part2 *= 10;
-        delta *= 10;
-        kappa--;
-        unsigned digit = (unsigned) (part2 >> -one.exp);
-        if (digit || idx) {
-            digits[idx++] = digit + '0';
-        }
-        part2 &= one.frac - 1;
-        if (part2 < delta) {
-            *K += kappa;
-            round_digit(digits, idx, delta, part2, one.frac, wfrac * *unit);
-            return idx;
-        }
-        unit--;
-    }
-}
-static int grisu2(double d, char* digits, int* K)
-{
-    Fp w = build_fp(d);
-    Fp lower, upper;
-    get_normalized_boundaries(&w, &lower, &upper);
-    normalize(&w);
-    int k;
-    Fp cp = find_cachedpow10(upper.exp, &k);
-    w     = multiply(&w,     &cp);
-    upper = multiply(&upper, &cp);
-    lower = multiply(&lower, &cp);
-    lower.frac++;
-    upper.frac--;
-    *K = -k;
-    return generate_digits(&w, &upper, &lower, digits, K);
-}
-static int emit_digits(char* digits, int ndigits, char* dest, int K, bool neg)
-{
-    int exp = absv(K + ndigits - 1);
-    if(K >= 0 && exp < 15) {
-        memcpy(dest, digits, ndigits);
-        memset(dest + ndigits, '0', K);
-        /* add a .0 to mark this as a float. */
-        dest[ndigits + K] = '.';
-        dest[ndigits + K + 1] = '0';
-        return ndigits + K + 2;
-    }
-    /* write decimal w/o scientific notation */
-    if(K < 0 && (K > -7 || exp < 10)) {
-        int offset = ndigits - absv(K);
-        /* fp < 1.0 -> write leading zero */
-        if(offset <= 0) {
-            offset = -offset;
-            dest[0] = '0';
-            dest[1] = '.';
-            memset(dest + 2, '0', offset);
-            memcpy(dest + offset + 2, digits, ndigits);
-            return ndigits + 2 + offset;
-        /* fp > 1.0 */
-        } else {
-            memcpy(dest, digits, offset);
-            dest[offset] = '.';
-            memcpy(dest + offset + 1, digits + offset, ndigits - offset);
-            return ndigits + 1;
-        }
-    }
-    /* write decimal w/ scientific notation */
-    ndigits = minv(ndigits, 18 - neg);
-    int idx = 0;
-    dest[idx++] = digits[0];
-    if(ndigits > 1) {
-        dest[idx++] = '.';
-        memcpy(dest + idx, digits + 1, ndigits - 1);
-        idx += ndigits - 1;
-    }
-    dest[idx++] = 'e';
-    char sign = K + ndigits - 1 < 0 ? '-' : '+';
-    dest[idx++] = sign;
-    int cent = 0;
-    if(exp > 99) {
-        cent = exp / 100;
-        dest[idx++] = cent + '0';
-        exp -= cent * 100;
-    }
-    if(exp > 9) {
-        int dec = exp / 10;
-        dest[idx++] = dec + '0';
-        exp -= dec * 10;
-    } else if(cent) {
-        dest[idx++] = '0';
-    }
-    dest[idx++] = exp % 10 + '0';
-    return idx;
-}
-static int filter_special(double fp, char* dest)
-{
-    if(fp == 0.0) {
-        dest[0] = '0';
-        dest[1] = '.';
-        dest[2] = '0';
-        return 3;
-    }
-    uint64_t bits = get_dbits(fp);
-    bool nan = (bits & expmask) == expmask;
-    if(!nan) {
-        return 0;
-    }
-    if(bits & fracmask) {
-        dest[0] = 'n'; dest[1] = 'a'; dest[2] = 'n';
-    } else {
-        dest[0] = 'i'; dest[1] = 'n'; dest[2] = 'f';
-    }
-    return 3;
-}
-/* Fast and accurate double to string conversion based on Florian Loitsch's
- * Grisu-algorithm[1].
- *
- * Input:
- * fp -> the double to convert, dest -> destination buffer.
- * The generated string will never be longer than 32 characters.
- * Make sure to pass a pointer to at least 32 bytes of memory.
- * The emitted string will not be null terminated.
- *
- *
- *
- * Output:
- * The number of written characters.
- *
- * Exemplary usage:
- *
- * void print(double d)
- * {
- *      char buf[28 + 1] // plus null terminator
- *      int str_len = fpconv_dtoa(d, buf);
- *
- *      buf[str_len] = '\0';
- *      printf("%s", buf);
- * }
- *
- */
-static int fpconv_dtoa(double d, char dest[28])
-{
-    char digits[18];
-    int str_len = 0;
-    bool neg = false;
-    if(get_dbits(d) & signmask) {
-        dest[0] = '-';
-        str_len++;
-        neg = true;
-    }
-    int spec = filter_special(d, dest + str_len);
-    if(spec) {
-        return str_len + spec;
-    }
-    int K = 0;
-    int ndigits = grisu2(d, digits, &K);
-    str_len += emit_digits(digits, ndigits, dest + str_len, K, neg);
-#ifdef JSON_DEBUG
-    assert(str_len <= 32);
-#endif
-    return str_len;
-}