text: // 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.
  
  // Runtime compiler options:
  // -DRYU_DEBUG Generate verbose debugging output to stdout.
  
  #include "src/ryu/ryu.h"
  
  #include <assert.h>
  #include <limits.h>
  #include <stdbool.h>
  #include <stdint.h>
  #include <stdlib.h>
  #include <string.h>
  
  #ifdef RYU_DEBUG
  #include <stdio.h>
  #endif
  
  #include "src/ryu/common.h"
  #include "src/ryu/digit_table.h"
  
  #if defined(RYU_FLOAT_FULL_TABLE)
  
  #include "ryu/f2s_full_table.h"
  
  #else
  
  #if defined(RYU_OPTIMIZE_SIZE)
  #include "ryu/d2s_small_table.h"
  #else
  #include "src/ryu/d2s_full_table.h"
  #endif
  #define FLOAT_POW5_INV_BITCOUNT (DOUBLE_POW5_INV_BITCOUNT - 64)
  #define FLOAT_POW5_BITCOUNT (DOUBLE_POW5_BITCOUNT - 64)
  
  #endif
  
  #define FLOAT_MANTISSA_BITS 23
  #define FLOAT_EXPONENT_BITS 8
  #define FLOAT_BIAS 127
  
  static inline uint32_t pow5factor_32(uint32_t value) {
    uint32_t count = 0;
    for (;;) {
      assert(value != 0);
      const uint32_t q = value / 5;
      const uint32_t r = value % 5;
      if (r != 0) {
        break;
      }
      value = q;
      ++count;
    }
    return count;
  }
  
  // Returns true if value is divisible by 5^p.
  static inline bool multipleOfPowerOf5_32(const uint32_t value,
                                           const uint32_t p) {
    return pow5factor_32(value) >= p;
  }
  
  // Returns true if value is divisible by 2^p.
  static inline bool multipleOfPowerOf2_32(const uint32_t value,
                                           const uint32_t p) {
    // __builtin_ctz doesn't appear to be faster here.
    return (value & ((1u << p) - 1)) == 0;
  }
  
  // It seems to be slightly faster to avoid uint128_t here, although the
  // generated code for uint128_t looks slightly nicer.
  static inline uint32_t mulShift32(const uint32_t m, const uint64_t factor,
                                    const int32_t shift) {
    assert(shift > 32);
  
    // The casts here help MSVC to avoid calls to the __allmul library
    // function.
    const uint32_t factorLo = (uint32_t)(factor);
    const uint32_t factorHi = (uint32_t)(factor >> 32);
    const uint64_t bits0 = (uint64_t)m * factorLo;
    const uint64_t bits1 = (uint64_t)m * factorHi;
  
  #ifdef RYU_32_BIT_PLATFORM
    // On 32-bit platforms we can avoid a 64-bit shift-right since we only
    // need the upper 32 bits of the result and the shift value is > 32.
    const uint32_t bits0Hi = (uint32_t)(bits0 >> 32);
    uint32_t bits1Lo = (uint32_t)(bits1);
    uint32_t bits1Hi = (uint32_t)(bits1 >> 32);
    bits1Lo += bits0Hi;
    bits1Hi += (bits1Lo < bits0Hi);
    const int32_t s = shift - 32;
    return (bits1Hi << (32 - s)) | (bits1Lo >> s);
  #else  // RYU_32_BIT_PLATFORM
    const uint64_t sum = (bits0 >> 32) + bits1;
    const uint64_t shiftedSum = sum >> (shift - 32);
    assert(shiftedSum <= UINT32_MAX);
    return (uint32_t)shiftedSum;
  #endif // RYU_32_BIT_PLATFORM
  }
  
  static inline uint32_t mulPow5InvDivPow2(const uint32_t m, const uint32_t q,
                                           const int32_t j) {
  #if defined(RYU_FLOAT_FULL_TABLE)
    return mulShift32(m, FLOAT_POW5_INV_SPLIT[q], j);
  #elif defined(RYU_OPTIMIZE_SIZE)
    // The inverse multipliers are defined as [2^x / 5^y] + 1; the upper 64 bits
    // from the double lookup table are the correct bits for [2^x / 5^y], so we
    // have to add 1 here. Note that we rely on the fact that the added 1 that's
    // already stored in the table never overflows into the upper 64 bits.
    uint64_t pow5[2];
    double_computeInvPow5(q, pow5);
    return mulShift32(m, pow5[1] + 1, j);
  #else
    return mulShift32(m, DOUBLE_POW5_INV_SPLIT[q][1] + 1, j);
  #endif
  }
  
  static inline uint32_t mulPow5divPow2(const uint32_t m, const uint32_t i,
                                        const int32_t j) {
  #if defined(RYU_FLOAT_FULL_TABLE)
    return mulShift32(m, FLOAT_POW5_SPLIT[i], j);
  #elif defined(RYU_OPTIMIZE_SIZE)
    uint64_t pow5[2];
    double_computePow5(i, pow5);
    return mulShift32(m, pow5[1], j);
  #else
    return mulShift32(m, DOUBLE_POW5_SPLIT[i][1], j);
  #endif
  }
  
  // A floating decimal representing m * 10^e.
  typedef struct floating_decimal_32 {
    uint32_t mantissa;
    // Decimal exponent's range is -45 to 38
    // inclusive, and can fit in a short if needed.
    int32_t exponent;
  } floating_decimal_32;
  
  static inline floating_decimal_32 f2d(const uint32_t ieeeMantissa,
                                        const uint32_t ieeeExponent) {
    int32_t e2;
    uint32_t m2;
    if (ieeeExponent == 0) {
      // We subtract 2 so that the bounds computation has 2 additional bits.
      e2 = 1 - FLOAT_BIAS - FLOAT_MANTISSA_BITS - 2;
      m2 = ieeeMantissa;
    } else {
      e2 = (int32_t)ieeeExponent - FLOAT_BIAS - FLOAT_MANTISSA_BITS - 2;
      m2 = (1u << FLOAT_MANTISSA_BITS) | ieeeMantissa;
    }
    const bool even = (m2 & 1) == 0;
    const bool acceptBounds = even;
  
  #ifdef RYU_DEBUG
    printf("-> %u * 2^%d\n", m2, e2 + 2);
  #endif
  
    // Step 2: Determine the interval of valid decimal representations.
    const uint32_t mv = 4 * m2;
    const uint32_t mp = 4 * m2 + 2;
    // Implicit bool -> int conversion. True is 1, false is 0.
    const uint32_t mmShift = ieeeMantissa != 0 || ieeeExponent <= 1;
    const uint32_t mm = 4 * m2 - 1 - mmShift;
  
    // Step 3: Convert to a decimal power base using 64-bit arithmetic.
    uint32_t vr, vp, vm;
    int32_t e10;
    bool vmIsTrailingZeros = false;
    bool vrIsTrailingZeros = false;
    uint8_t lastRemovedDigit = 0;
    if (e2 >= 0) {
      const uint32_t q = log10Pow2(e2);
      e10 = (int32_t)q;
      const int32_t k = FLOAT_POW5_INV_BITCOUNT + pow5bits((int32_t)q) - 1;
      const int32_t i = -e2 + (int32_t)q + k;
      vr = mulPow5InvDivPow2(mv, q, i);
      vp = mulPow5InvDivPow2(mp, q, i);
      vm = mulPow5InvDivPow2(mm, q, i);
  #ifdef RYU_DEBUG
      printf("%u * 2^%d / 10^%u\n", mv, e2, q);
      printf("V+=%u\nV =%u\nV-=%u\n", vp, vr, vm);
  #endif
      if (q != 0 && (vp - 1) / 10 <= vm / 10) {
        // We need to know one removed digit even if we are not going to loop
        // below. We could use q = X - 1 above, except that would require 33 bits
        // for the result, and we've found that 32-bit arithmetic is faster even
        // on 64-bit machines.
        const int32_t l =
            FLOAT_POW5_INV_BITCOUNT + pow5bits((int32_t)(q - 1)) - 1;
        lastRemovedDigit = (uint8_t)(
            mulPow5InvDivPow2(mv, q - 1, -e2 + (int32_t)q - 1 + l) % 10);
      }
      if (q <= 9) {
        // The largest power of 5 that fits in 24 bits is 5^10, but q <= 9 seems
        // to be safe as well. Only one of mp, mv, and mm can be a multiple of 5,
        // if any.
        if (mv % 5 == 0) {
          vrIsTrailingZeros = multipleOfPowerOf5_32(mv, q);
        } else if (acceptBounds) {
          vmIsTrailingZeros = multipleOfPowerOf5_32(mm, q);
        } else {
          vp -= multipleOfPowerOf5_32(mp, q);
        }
      }
    } else {
      const uint32_t q = log10Pow5(-e2);
      e10 = (int32_t)q + e2;
      const int32_t i = -e2 - (int32_t)q;
      const int32_t k = pow5bits(i) - FLOAT_POW5_BITCOUNT;
      int32_t j = (int32_t)q - k;
      vr = mulPow5divPow2(mv, (uint32_t)i, j);
      vp = mulPow5divPow2(mp, (uint32_t)i, j);
      vm = mulPow5divPow2(mm, (uint32_t)i, j);
  #ifdef RYU_DEBUG
      printf("%u * 5^%d / 10^%u\n", mv, -e2, q);
      printf("%u %d %d %d\n", q, i, k, j);
      printf("V+=%u\nV =%u\nV-=%u\n", vp, vr, vm);
  #endif
      if (q != 0 && (vp - 1) / 10 <= vm / 10) {
        j = (int32_t)q - 1 - (pow5bits(i + 1) - FLOAT_POW5_BITCOUNT);
        lastRemovedDigit =
            (uint8_t)(mulPow5divPow2(mv, (uint32_t)(i + 1), j) % 10);
      }
      if (q <= 1) {
        // {vr,vp,vm} is trailing zeros if {mv,mp,mm} has at least q trailing 0
        // bits. mv = 4 * m2, so it always has at least two trailing 0 bits.
        vrIsTrailingZeros = true;
        if (acceptBounds) {
          // mm = mv - 1 - mmShift, so it has 1 trailing 0 bit iff mmShift == 1.
          vmIsTrailingZeros = mmShift == 1;
        } else {
          // mp = mv + 2, so it always has at least one trailing 0 bit.
          --vp;
        }
      } else if (q < 31) { // TODO(ulfjack): Use a tighter bound here.
        vrIsTrailingZeros = multipleOfPowerOf2_32(mv, q - 1);
  #ifdef RYU_DEBUG
        printf("vr is trailing zeros=%s\n", vrIsTrailingZeros ? "true" : "false");
  #endif
      }
    }
  #ifdef RYU_DEBUG
    printf("e10=%d\n", e10);
    printf("V+=%u\nV =%u\nV-=%u\n", vp, vr, vm);
    printf("vm is trailing zeros=%s\n", vmIsTrailingZeros ? "true" : "false");
    printf("vr is trailing zeros=%s\n", vrIsTrailingZeros ? "true" : "false");
  #endif
  
    // Step 4: Find the shortest decimal representation in the interval of valid
    // representations.
    int32_t removed = 0;
    uint32_t output;
    if (vmIsTrailingZeros || vrIsTrailingZeros) {
      // General case, which happens rarely (~4.0%).
      while (vp / 10 > vm / 10) {
  #ifdef __clang__ // https://bugs.llvm.org/show_bug.cgi?id=23106
        // The compiler does not realize that vm % 10 can be computed from vm / 10
        // as vm - (vm / 10) * 10.
        vmIsTrailingZeros &= vm - (vm / 10) * 10 == 0;
  #else
        vmIsTrailingZeros &= vm % 10 == 0;
  #endif
        vrIsTrailingZeros &= lastRemovedDigit == 0;
        lastRemovedDigit = (uint8_t)(vr % 10);
        vr /= 10;
        vp /= 10;
        vm /= 10;
        ++removed;
      }
  #ifdef RYU_DEBUG
      printf("V+=%u\nV =%u\nV-=%u\n", vp, vr, vm);
      printf("d-10=%s\n", vmIsTrailingZeros ? "true" : "false");
  #endif
      if (vmIsTrailingZeros) {
        while (vm % 10 == 0) {
          vrIsTrailingZeros &= lastRemovedDigit == 0;
          lastRemovedDigit = (uint8_t)(vr % 10);
          vr /= 10;
          vp /= 10;
          vm /= 10;
          ++removed;
        }
      }
  #ifdef RYU_DEBUG
      printf("%u %d\n", vr, lastRemovedDigit);
      printf("vr is trailing zeros=%s\n", vrIsTrailingZeros ? "true" : "false");
  #endif
      if (vrIsTrailingZeros && lastRemovedDigit == 5 && vr % 2 == 0) {
        // Round even if the exact number is .....50..0.
        lastRemovedDigit = 4;
      }
      // We need to take vr + 1 if vr is outside bounds or we need to round up.
      output = vr + ((vr == vm && (!acceptBounds || !vmIsTrailingZeros)) ||
                     lastRemovedDigit >= 5);
    } else {
      // Specialized for the common case (~96.0%). Percentages below are relative
      // to this. Loop iterations below (approximately): 0: 13.6%, 1: 70.7%,
      // 2: 14.1%, 3: 1.39%, 4: 0.14%, 5+: 0.01%
      while (vp / 10 > vm / 10) {
        lastRemovedDigit = (uint8_t)(vr % 10);
        vr /= 10;
        vp /= 10;
        vm /= 10;
        ++removed;
      }
  #ifdef RYU_DEBUG
      printf("%u %d\n", vr, lastRemovedDigit);
      printf("vr is trailing zeros=%s\n", vrIsTrailingZeros ? "true" : "false");
  #endif
      // We need to take vr + 1 if vr is outside bounds or we need to round up.
      output = vr + (vr == vm || lastRemovedDigit >= 5);
    }
    const int32_t exp = e10 + removed;
  
  #ifdef RYU_DEBUG
    printf("V+=%u\nV =%u\nV-=%u\n", vp, vr, vm);
    printf("O=%u\n", output);
    printf("EXP=%d\n", exp);
  #endif
  
    floating_decimal_32 fd;
    fd.exponent = exp;
    fd.mantissa = output;
    return fd;
  }
  
  static inline int to_chars(const floating_decimal_32 v, const bool sign,
                             char *const result) {
    // Step 5: Print the decimal representation.
    int index = 0;
    if (sign) {
      result[index++] = '-';
    }
  
    uint32_t output = v.mantissa;
    const uint32_t olength = decimalLength9(output);
  
  #ifdef RYU_DEBUG
    printf("DIGITS=%u\n", v.mantissa);
    printf("OLEN=%u\n", olength);
    printf("EXP=%u\n", v.exponent + olength);
  #endif
  
    // 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;
    while (output >= 10000) {
  #ifdef __clang__ // https://bugs.llvm.org/show_bug.cgi?id=38217
      const uint32_t c = output - 10000 * (output / 10000);
  #else
      const uint32_t c = output % 10000;
  #endif
      output /= 10000;
      const uint32_t c0 = (c % 100) << 1;
      const uint32_t c1 = (c / 100) << 1;
      memcpy(result + index + olength - i - 1, DIGIT_TABLE + c0, 2);
      memcpy(result + index + olength - i - 3, DIGIT_TABLE + c1, 2);
      i += 4;
    }
    if (output >= 100) {
      const uint32_t c = (output % 100) << 1;
      output /= 100;
      memcpy(result + index + olength - i - 1, DIGIT_TABLE + c, 2);
      i += 2;
    }
    if (output >= 10) {
      const uint32_t c = output << 1;
      // We can't use memcpy here: the decimal dot goes between these two digits.
      result[index + olength - i] = DIGIT_TABLE[c + 1];
      result[index] = DIGIT_TABLE[c];
    } else {
      result[index] = (char)('0' + output);
    }
  
    // Print decimal point if needed.
    if (olength > 1) {
      result[index + 1] = '.';
      index += olength + 1;
    } else {
      ++index;
    }
  
    // Print the exponent.
    result[index++] = 'E';
    int32_t exp = v.exponent + (int32_t)olength - 1;
    if (exp < 0) {
      result[index++] = '-';
      exp = -exp;
    }
  
    if (exp >= 10) {
      memcpy(result + index, DIGIT_TABLE + 2 * exp, 2);
      index += 2;
    } else {
      result[index++] = (char)('0' + exp);
    }
  
    return index;
  }
  
  int f2s_buffered_n(float f, char *result) {
    // Step 1: Decode the floating-point number, and unify normalized and
    // subnormal cases.
    const uint32_t bits = float_to_bits(f);
  
  #ifdef RYU_DEBUG
    printf("IN=");
    for (int32_t bit = 31; bit >= 0; --bit) {
      printf("%u", (bits >> bit) & 1);
    }
    printf("\n");
  #endif
  
    // Decode bits into sign, mantissa, and exponent.
    const bool ieeeSign =
        ((bits >> (FLOAT_MANTISSA_BITS + FLOAT_EXPONENT_BITS)) & 1) != 0;
    const uint32_t ieeeMantissa = bits & ((1u << FLOAT_MANTISSA_BITS) - 1);
    const uint32_t ieeeExponent =
        (bits >> FLOAT_MANTISSA_BITS) & ((1u << FLOAT_EXPONENT_BITS) - 1);
  
    // Case distinction; exit early for the easy cases.
    if (ieeeExponent == ((1u << FLOAT_EXPONENT_BITS) - 1u) ||
        (ieeeExponent == 0 && ieeeMantissa == 0)) {
      return copy_special_str(result, ieeeSign, ieeeExponent, ieeeMantissa);
    }
  
    const floating_decimal_32 v = f2d(ieeeMantissa, ieeeExponent);
    return to_chars(v, ieeeSign, result);
  }
  
  void f2s_buffered(float f, char *result) {
    const int index = f2s_buffered_n(f, result);
  
    // Terminate the string.
    result[index] = '\0';
  }
  
  char *f2s(float f) {
    char *const result = (char *)malloc(16);
    f2s_buffered(f, result);
    return result;
  }
  