Method generateDigits

choc/text/choc_FloatToString.h:119–174

    };

    static uint32_t generateDigits (char* buffer, MantissaAndExponent upperBound, uint64_t mantissaDiff, uint64_t delta, int& K)
    {
        uint32_t length = 0;
        const auto one = MantissaAndExponent { 1ull << -upperBound.exponent, upperBound.exponent };
        auto p1 = static_cast<uint32_t> (upperBound.mantissa >> -one.exponent);
        auto p2 = upperBound.mantissa & (one.mantissa - 1);
        auto numDigits = math::getNumDecimalDigits (p1);

        for (;;)
        {
            auto digit = p1;

            switch (--numDigits)
            {
                case 0:                           p1 = 0;              break;
                case 1:  digit /= powersOf10[1];  p1 %= powersOf10[1]; break;
                case 2:  digit /= powersOf10[2];  p1 %= powersOf10[2]; break;
                case 3:  digit /= powersOf10[3];  p1 %= powersOf10[3]; break;
                case 4:  digit /= powersOf10[4];  p1 %= powersOf10[4]; break;
                case 5:  digit /= powersOf10[5];  p1 %= powersOf10[5]; break;
                case 6:  digit /= powersOf10[6];  p1 %= powersOf10[6]; break;
                case 7:  digit /= powersOf10[7];  p1 %= powersOf10[7]; break;
                case 8:  digit /= powersOf10[8];  p1 %= powersOf10[8]; break;
                default: break;
            }

            writeDigitIfNotLeadingZero (buffer, length, digit);
            auto rest = p2 + (static_cast<uint64_t> (p1) << -one.exponent);

            if (rest <= delta)
            {
                K += numDigits;
                roundFinalDigit (buffer, length, delta, rest, static_cast<uint64_t> (powersOf10[numDigits]) << -one.exponent, mantissaDiff);
                return length;
            }

            if (numDigits == 0)
            {
                for (;;)
                {
                    delta *= 10;
                    p2 *= 10;
                    --numDigits;
                    writeDigitIfNotLeadingZero (buffer, length, static_cast<uint32_t> (p2 >> -one.exponent));
                    p2 &= one.mantissa - 1;

                    if (p2 < delta)
                    {
                        K += numDigits;
                        roundFinalDigit (buffer, length, delta, p2, one.mantissa, numDigits > -9 ? mantissaDiff * powersOf10[-numDigits] : 0);
                        return length;
                    }
                }
            }
        }
    }

    static void roundFinalDigit (char* buffer, uint32_t length, uint64_t delta, uint64_t rest, uint64_t tenToPowerNumDigits, uint64_t diff)