strtodI.c File Reference

#include "gdtoaimp.h"

Include dependency graph for strtodI.c:

Go to the source code of this file.

Functions
static double	ulpdown (double *d)
int	strtodI (CONST char *s, char **sp, double *dd)

Function Documentation

strtodI()

int strtodI	(	CONST char *	s,
		char **	sp,
		double *	dd
	)

Definition at line 60 of file strtodI.c.

{
    static FPI fpi = {53, 1 - 1023 - 53 + 1, 2046 - 1023 - 53 + 1, 1, SI};
    ULong bits[2], sign;
    Long exp;
    int j, k;
    typedef union
    {
        double d[2];
        ULong L[4];
    } U2;
    U2* u;

    k = strtodg(s, sp, &fpi, &exp, bits);
    u = (U2*)dd;
    sign = (k & STRTOG_Neg) ? 0x80000000L : 0;
    switch(k & STRTOG_Retmask)
    {
        case STRTOG_NoNumber:
            u->d[0] = u->d[1] = 0.;
            break;

        case STRTOG_Zero:
            u->d[0] = u->d[1] = 0.;
#ifdef Sudden_Underflow
            if(k & STRTOG_Inexact)
            {
                if(sign)
                    u->L[_0] = 0x80100000L;
                else
                    u->L[2 + _0] = 0x100000L;
            }
            break;
#else
            goto contain;
#endif

        case STRTOG_Denormal:
            u->L[_1] = bits[0];
            u->L[_0] = bits[1];
            goto contain;

        case STRTOG_Normal:
            u->L[_1] = bits[0];
            u->L[_0] = (bits[1] & (unsigned)~0x100000) | (unsigned)((exp + 0x3ff + 52) << 20);
        contain:
            j = k & STRTOG_Inexact;
            if(sign)
            {
                u->L[_0] |= sign;
                j = STRTOG_Inexact - j;
            }
            switch(j)
            {
                case STRTOG_Inexlo:
#ifdef Sudden_Underflow
                    if((u->L[_0] & 0x7ff00000) < 0x3500000)
                    {
                        u->L[2 + _0] = u->L[_0] + 0x3500000;
                        u->L[2 + _1] = u->L[_1];
                        u->d[1] += ulp(u->d[1]);
                        u->L[2 + _0] -= 0x3500000;
                        if(!(u->L[2 + _0] & 0x7ff00000))
                        {
                            u->L[2 + _0] = sign;
                            u->L[2 + _1] = 0;
                        }
                    }
                    else
#endif
                        u->d[1] = u->d[0] + ulp(u->d[0]);
                    break;
                case STRTOG_Inexhi:
                    u->d[1] = u->d[0];
#ifdef Sudden_Underflow
                    if((u->L[_0] & 0x7ff00000) < 0x3500000)
                    {
                        u->L[_0] += 0x3500000;
                        u->d[0] -= ulpdown(u->d);
                        u->L[_0] -= 0x3500000;
                        if(!(u->L[_0] & 0x7ff00000))
                        {
                            u->L[_0] = sign;
                            u->L[_1] = 0;
                        }
                    }
                    else
#endif
                        u->d[0] -= ulpdown(u->d);
                    break;
                default:
                    u->d[1] = u->d[0];
            }
            break;

        case STRTOG_Infinite:
            u->L[_0] = u->L[2 + _0] = sign | 0x7ff00000;
            u->L[_1] = u->L[2 + _1] = 0;
            if(k & STRTOG_Inexact)
            {
                if(sign)
                {
                    u->L[2 + _0] = 0xffefffffL;
                    u->L[2 + _1] = 0xffffffffL;
                }
                else
                {
                    u->L[_0] = 0x7fefffffL;
                    u->L[_1] = 0xffffffffL;
                }
            }
            break;

        case STRTOG_NaN:
            u->L[0] = u->L[2] = d_QNAN0;
            u->L[1] = u->L[3] = d_QNAN1;
            break;

        case STRTOG_NaNbits:
            u->L[_0] = u->L[2 + _0] = 0x7ff00000 | sign | bits[1];
            u->L[_1] = u->L[2 + _1] = bits[0];
    }
    return k;
}

References Long, SI, strtodg(), STRTOG_Denormal, STRTOG_Inexact, STRTOG_Inexhi, STRTOG_Inexlo, STRTOG_Infinite, STRTOG_NaN, STRTOG_NaNbits, STRTOG_Neg, STRTOG_NoNumber, STRTOG_Normal, STRTOG_Retmask, STRTOG_Zero, ulp(), and ulpdown().

ulpdown()

static double ulpdown ( double *  d )

static

Definition at line 38 of file strtodI.c.

{
    double u;
    ULong* L = (ULong*)d;

    u = ulp(*d);
    if(!(L[_1] | (L[_0] & 0xfffff)) && (L[_0] & 0x7ff00000) > 0x00100000)
    {
        {
            u *= 0.5;
        }
    }
    return u;
}

References ulp().

Referenced by strtodI().