float number to string converting implementation in STD

Question

I faced with a curious issue. Look at this simple code:

int main(int argc, char **argv) {
    char buf[1000];
    snprintf_l(buf, sizeof(buf), _LIBCPP_GET_C_LOCALE, "%.17f", 0.123e30f);
    std::cout << "WTF?: " << buf << std::endl;
}

The output looks quire wired:

123000004117574256822262431744.00000000000000000

My question is how it's implemented? Can someone show me the original code? I did not find it. Or maybe it's too complicated for me.

I've tried to reimplement the same transformation double to string with Java code but was failed. Even when I tried to get exponent and fraction parts separately and summarize fractions in cycle I always get zeros instead of these numbers "...822262431744". When I tried to continue summarizing fractions after the 23 bits (for float number) I faced with other issue - how many fractions I need to collect? Why the original code stops on left part and does not continue until the scale is end? So, I really do not understand the basic logic, how it implemented. I've tried to define really big numbers (e.g. 0.123e127f). And it generates huge number in decimal format. The number has much higher precision than float can be. Looks like this is an issue, because the string representation contains something which float number cannot.

Answer 1

Finally I've found out what the difference between Java float -> decimal -> string conversion and c++ float -> string (decimal) conversion. I did not find the original source code, but I replicated the same code in Java to make it clear. I think the code explains everything:

    // the context size might be calculated properly by getting maximum 
    // float number (including exponent value) - its 40 + scale, 17 for me
    MathContext context = new MathContext(57, RoundingMode.HALF_UP);
    BigDecimal divisor = BigDecimal.valueOf(2);
    int tmp = Float.floatToRawIntBits(1.23e30f)
    boolean sign = tmp < 0;
    tmp <<= 1;
    // there might be NaN value, this code does not support it
    int exponent = (tmp >>> 24) - 127;
    tmp <<= 8;
    int mask = 1 << 23;
    int fraction = mask | (tmp >>> 9);
    // at this line we have all parts of the float: sign, exponent and fractions. Let's build mantissa
    BigDecimal mantissa = BigDecimal.ZERO;
    for (int i = 0; i < 24; i ++) {
        if ((fraction & mask) == mask) {
            // i'm not sure about speed, maybe division at each iteration might be faster than pow
            mantissa = mantissa.add(divisor.pow(-i, context));
        }
        mask >>>= 1;
    }

    // it was the core line where I was losing accuracy, because of context
    BigDecimal decimal = mantissa.multiply(divisor.pow(exponent, context), context);
    String str = decimal.setScale(17, RoundingMode.HALF_UP).toPlainString();
    // add minus manually, because java lost it if after the scale value become 0, C++ version of code doesn't do it
    if (sign) {
        str = "-" + str;
    }
    return str;

Maybe topic is useless. Who really need to have the same implementation like C++ has? But at least this code keeps all precision for float number comparing to the most popular way converting float to decimal string:

    return BigDecimal.valueOf(1.23e30f).setScale(17, RoundingMode.HALF_UP).toPlainString();