#define FDIGIT  30
#define FDEFLT  6
#define NSIGNIF 17

static uvlong uvnan    = ((uvlong)0x7FF00000<<32)|0x00000001;
static uvlong uvinf    = ((uvlong)0x7FF00000<<32)|0x00000000;
static uvlong uvneginf = ((uvlong)0xFFF00000<<32)|0x00000000;

static char *special[] = { "NaN", "NaN", "+Inf", "+Inf", "-Inf", "-Inf" };

static int
isNaN(double val)
{
    union{
        uvlong i;
        double f;
    }x;

    x.f = val;
    return (x.i&uvinf) == uvinf && (x.i&~uvneginf) != 0;
}

static double
NaN(void)
{
    union{
        uvlong i;
        double f;
    }x;
    x.i = uvnan;
    return x.f;
}

static int
isInf(double val, int sign)
{
    union{
        uvlong i;
        double f;
    }x;

    x.f = val;
    if(sign == 0)
        return x.i == uvinf || x.i == uvneginf;
    else if(sign == 1)
        return x.i == uvinf;
    else
        return x.i == uvneginf;
}

static double pows10[] =
{
      1e0,   1e1,   1e2,   1e3,   1e4,   1e5,   1e6,   1e7,   1e8,   1e9,
     1e10,  1e11,  1e12,  1e13,  1e14,  1e15,  1e16,  1e17,  1e18,  1e19,
     1e20,  1e21,  1e22,  1e23,  1e24,  1e25,  1e26,  1e27,  1e28,  1e29,
     1e30,  1e31,  1e32,  1e33,  1e34,  1e35,  1e36,  1e37,  1e38,  1e39,
     1e40,  1e41,  1e42,  1e43,  1e44,  1e45,  1e46,  1e47,  1e48,  1e49,
     1e50,  1e51,  1e52,  1e53,  1e54,  1e55,  1e56,  1e57,  1e58,  1e59,
     1e60,  1e61,  1e62,  1e63,  1e64,  1e65,  1e66,  1e67,  1e68,  1e69,
     1e70,  1e71,  1e72,  1e73,  1e74,  1e75,  1e76,  1e77,  1e78,  1e79,
     1e80,  1e81,  1e82,  1e83,  1e84,  1e85,  1e86,  1e87,  1e88,  1e89,
     1e90,  1e91,  1e92,  1e93,  1e94,  1e95,  1e96,  1e97,  1e98,  1e99,
    1e100, 1e101, 1e102, 1e103, 1e104, 1e105, 1e106, 1e107, 1e108, 1e109,
    1e110, 1e111, 1e112, 1e113, 1e114, 1e115, 1e116, 1e117, 1e118, 1e119,
    1e120, 1e121, 1e122, 1e123, 1e124, 1e125, 1e126, 1e127, 1e128, 1e129,
    1e130, 1e131, 1e132, 1e133, 1e134, 1e135, 1e136, 1e137, 1e138, 1e139,
    1e140, 1e141, 1e142, 1e143, 1e144, 1e145, 1e146, 1e147, 1e148, 1e149,
    1e150, 1e151, 1e152, 1e153, 1e154, 1e155, 1e156, 1e157, 1e158, 1e159,
};

static double
fpow10(int n)
{
    double d;
    int neg;

    neg = 0;
    if(n < 0){
        neg = 1;
        n = -n;
    }

    if(n<arrlen(pows10))
        d = pows10[n];
    else{
        d = pows10[arrlen(pows10)-1];
        for(;;){
            n -= arrlen(pows10)- 1;
            if(n < arrlen(pows10)){
                d *= pows10[n];
                break;
            }
            d *= pows10[arrlen(pows10)- 1];
        }
    }
    if(neg)
        return 1./d;
    return d;
}

static int
add1(char *a, int n)
{
    int c;
    char *b;

    if(n < 0 || n > NSIGNIF)
        return 0;

    for(b = a+n-1; b >= a; b--){
        c = *b + 1;
        if(c <= '9'){
            *b = c;
            return 0;
        }
        *b = '0';
    }
    /*
     * need to overflow adding digit.
     * shift number down and insert 1 at beginning.
     * decimal is known to be 0s or we wouldn't
     * have gotten this far.  (e.g., 99999+1 => 00000)
     */
    a[0] = '1';
    return 1;
}

static int
sub1(char *a, int n)
{
    int c;
    char *b;

    if(n < 0 || n > NSIGNIF)
        return 0;
    for(b = a+n-1; b >= a; b--){
        c = *b - 1;
        if(c >= '0'){
            if(c == '0' && b == a){
                /*
                 * just zeroed the top digit; shift everyone up.
                 * decimal is known to be 9s or we wouldn't
                 * have gotten this far.  (e.g., 10000-1 => 09999)
                 */
                *b = '9';
                return 1;
            }
            *b = c;
            return 0;
        }
        *b = '9';
    }
    /*
     * can't get here.  the number a is always normalized
     * so that it has a nonzero first digit.
     */
    rt·exit(1);
}

static void
fmtexp(char *p, int e, int ucase)
{
    int i;
    char se[9];

    *p++ = ucase ? 'E' : 'e';
    if(e < 0){
        *p++ = '-';
        e = -e;
    }else
        *p++ = '+';

    i = 0;
    while(e){
        se[i++] = e % 10 + '0';
        e /= 10;
    }

    while(i < 2)
        se[i++] = '0';
    while(i > 0)
        *p++ = se[--i];

    *p++ = '\0';
}

/*
 * compute decimal integer m, exp such that:
 * f = m*10^exp
 * m is as short as possible with losing exactness
 * assumes special cases (NaN, +Inf, -Inf) have been handled.
 */
static void
dtoa(double f, char *s, int *exp, int *neg, int *len)
{
    int c, d, e2, e, ee, i, ndigit;
    char buf[NSIGNIF+10];
    double g;

    *neg = 0;
    if(f < 0){
        f = -f;
        *neg = 1;
    }

    if(f == 0){
        *exp = 0;
        s[0] = '0';
        s[1] = 0;
        *len = 1;
        return;
    }

    math·frexp(f, &e2);
    e = (int)(e2 * .301029995664);
    g = f * fpow10(-e);
    while(g < 1) {
        e--;
        g = f * fpow10(-e);
    }
    while(g >= 10){
        e++;
        g = f * fpow10(-e);
    }

    /* convert nsignif digits as a first approximation */
    for(i=0; i<NSIGNIF; i++){
        d = (int)g;
        s[i] = d+'0';
        g = (g-d)*10;
    }
    s[i] = 0;

    e -= NSIGNIF-1;
    fmtexp(s+NSIGNIF, e, 0);

    for(i=0; i<10; i++) {
        g=str·asfloat(s, nil);
        if(f > g) {
            if(add1(s, NSIGNIF)){
                /* gained a digit */
                e--;
                fmtexp(s+NSIGNIF, e, 0);
            }
            continue;
        }
        if(f < g){
            if(sub1(s, NSIGNIF)){
                /* lost a digit */
                e++;
                fmtexp(s+NSIGNIF, e, 0);
            }
            continue;
        }
        break;
    }

    /*
     * bump last few digits down to 0 as we can.
     */
    for(i=NSIGNIF-1; i>=NSIGNIF-3; i--){
        c = s[i];
        if(c != '0'){
            s[i] = '0';
            g=str·asfloat(s, nil);
            if(g != f){
                s[i] = c;
                break;
            }
        }
    }

    /*
     * remove trailing zeros.
     */
    ndigit = NSIGNIF;
    while(ndigit > 1 && s[ndigit-1] == '0'){
        e++;
        --ndigit;
    }
    s[ndigit] = 0;
    *exp = e;
    *len = ndigit;

    /* errno = oerrno; */
}


static int
fmtfloat(fmt·State *io)
{
    char buf[NSIGNIF+10], *dot, *digits, *p, *end, suf[10], *cur;
    double val;
    int c, verb, ndot, e, exp, f, ndigits, neg, newndigits;
    int npad, pt, prec, realverb, sign, nsuf, ucase, n, z1, z2;

    if(io->flag&fmt·Long)
        val = va_arg(io->args, long double);
    else
        val = va_arg(io->args, double);

    /* extract formatting flags */
    f = io->flag;
    io->flag = 0;
    prec = FDEFLT;
    if(f & fmt·Prec)
        prec = io->prec;

    verb = io->verb;
    ucase = 0;
    switch(verb) {
    case 'A':
    case 'E':
    case 'F':
    case 'G':
        verb += 'a'-'A';
        ucase = 1;
        break;
    }

    /* pick off special numbers. */
    if(isNaN(val)) {
        end = special[0+ucase];
    special:
        io->flag = f & (fmt·Width|fmt·Left);
        return copy(io, end, str·len(end), str·len(end));
    }
    if(isInf(val, 1)) {
        end = special[2+ucase];
        goto special;
    }
    if(isInf(val, -1)) {
        end = special[4+ucase];
        goto special;
    }

    /* get exact representation. */
    digits = buf;
    dtoa(val, digits, &exp, &neg, &ndigits);

    /* get locale's decimal point. */
    dot = io->decimal;
    if(dot == nil)
        dot = ".";
    ndot = utf8·len(dot);

    /*
     * now the formatting fun begins.
     * compute parameters for actual fmt:
     *
     *    pad: number of spaces to insert before/after field.
     *    z1: number of zeros to insert before digits
     *    z2: number of zeros to insert after digits
     *    point: number of digits to print before decimal point
     *    ndigits: number of digits to use from digits[]
     *    suf: trailing suffix, like "e-5"
     */
    realverb = verb;
    switch(verb){
    case 'g':
        /* convert to at most prec significant digits. (prec=0 means 1) */
        if(prec == 0)
            prec = 1;
        if(ndigits > prec) {
            if(digits[prec] >= '5' && add1(digits, prec))
                exp++;
            exp += ndigits-prec;
            ndigits = prec;
        }

        /*
         * extra rules for %g (implemented below):
         *    trailing zeros removed after decimal unless FmtSharp.
         *    decimal point only if digit follows.
         */

        /* fall through to %e */
    default:
    case 'e':
        /* one significant digit before decimal, no leading zeros. */
        pt = 1;
        z1 = 0;

        /*
         * decimal point is after ndigits digits right now.
         * slide to be after first.
         */
        e  = exp + (ndigits-1);

        /* if this is %g, check exponent and convert prec */
        if(realverb == 'g') {
            if(-4 <= e && e < prec)
                goto casef;
            prec--;    /* one digit before decimal; rest after */
        }

        /* compute trailing zero padding or truncate digits. */
        if(1+prec >= ndigits)
            z2 = 1+prec - ndigits;
        else {
            /* truncate digits */
            assert(realverb != 'g');
            newndigits = 1+prec;
            if(digits[newndigits] >= '5' && add1(digits, newndigits)) {
                /* had 999e4, now have 100e5 */
                e++;
            }
            ndigits = newndigits;
            z2 = 0;
        }
        fmtexp(suf, e, ucase);
        nsuf = str·len(suf);
        break;

    casef:
    case 'f':
        /* determine where digits go with respect to decimal point */
        if(ndigits+exp > 0) {
            pt = ndigits+exp;
            z1 = 0;
        } else {
            pt = 1;
            z1 = 1 + -(ndigits+exp);
        }

        /*
         * %g specifies prec = number of significant digits
         * convert to number of digits after decimal point
         */
        if(realverb == 'g')
            prec += z1 - pt;

        /* compute trailing zero padding or truncate digits. */
        if(pt+prec >= z1+ndigits)
            z2 = pt+prec - (z1+ndigits);
        else{
            /* truncate digits */
            assert(realverb != 'g');
            newndigits = pt+prec - z1;
            if(newndigits < 0){
                z1 += newndigits;
                newndigits = 0;
            }else if(newndigits == 0){
                /* perhaps round up */
                if(digits[0] >= '5'){
                    digits[0] = '1';
                    newndigits = 1;
                    goto newdigit;
                }
            }else if(digits[newndigits] >= '5' && add1(digits, newndigits)){
                /* digits was 999, is now 100; make it 1000 */
                digits[newndigits++] = '0';
            newdigit:
                /* account for new digit */
                if(z1)   /* 0.099 => 0.100 or 0.99 => 1.00*/
                    z1--;
                else    /* 9.99 => 10.00 */
                    pt++;
            }
            z2 = 0;
            ndigits = newndigits;
        }
        nsuf = 0;
        break;
    }

    /*
     * if %g is given without FmtSharp, remove trailing zeros.
     * must do after truncation, so that e.g. print %.3g 1.001
     * produces 1, not 1.00.  sorry, but them's the rules.
     */
    if(realverb == 'g' && !(f & fmt·Sharp)) {
        if(z1+ndigits+z2 >= pt) {
            if(z1+ndigits < pt)
                z2 = pt - (z1+ndigits);
            else{
                z2 = 0;
                while(z1+ndigits > pt && digits[ndigits-1] == '0')
                    ndigits--;
            }
        }
    }

    /*
     * compute width of all digits and decimal point and suffix if any
     */
    n = z1+ndigits+z2;
    if(n > pt)
        n += ndot;
    else if(n == pt){
        if(f & fmt·Sharp)
            n += ndot;
        else
            pt++;    /* do not print any decimal point */
    }
    n += nsuf;

    /*
     * determine sign
     */
    sign = 0;
    if(neg)
        sign = '-';
    else if(f & fmt·Sign)
        sign = '+';
    else if(f & fmt·Space)
        sign = ' ';
    if(sign)
        n++;

    /* compute padding */
    npad = 0;
    if((f & fmt·Width) && io->width > n)
        npad = io->width - n;
    if(npad && !(f & fmt·Left) && (f & fmt·Zero)){
        z1 += npad;
        pt += npad;
        npad = 0;
    }

    /* format the actual field.  too bad about doing this twice. */
    if(npad && !(f & fmt·Left) && pad(io, npad < 0))
        return -1;

    cur = io->buffer.cur;
    end = io->buffer.end;

    if(sign){
        if(cur+1 > end){
            if(!(cur=flush(io,cur,1)))
                return -1;
            end = io->buffer.end;
        }
        *cur++ = sign;
    }

    while(z1>0 || ndigits>0 || z2>0){
        if(z1 > 0){
            z1--;
            c = '0';
        }else if(ndigits > 0){
            ndigits--;
            c = *digits++;
        }else{
            z2--;
            c = '0';
        }

        if(cur+1 > end){
            if(!(cur=flush(io,cur,1)))
                return -1;
            end = io->buffer.end;
        }
        *cur++ = c;

        if(--pt == 0)
            for(p=dot; *p; p++){
                if(cur+1 > end){
                    if(!(cur=flush(io,cur,1)))
                        return -1;
                    end = io->buffer.end;
                }
                *cur++ = *p;
            }
    }
    io->n += cur - (char*)io->buffer.cur;
    io->buffer.cur = cur;
    if(nsuf && copy(io, suf, nsuf, nsuf) < 0)
        return -1;
    if(npad && (f & fmt·Left) && pad(io, npad < 0))
        return -1;

    return 0;
}