gethex.c File Reference

#include "gdtoaimp.h"

Include dependency graph for gethex.c:

Go to the source code of this file.

Macros
#define	decimalpoint   '.'

Functions
int	gethex (CONST char **sp, FPI *fpi, Long *exp, Bigint **bp, int sign)

Macro Definition Documentation

decimalpoint

#define decimalpoint   '.'

Function Documentation

gethex()

int gethex	(	CONST char **	sp,
		FPI *	fpi,
		Long *	exp,
		Bigint **	bp,
		int	sign
	)

Definition at line 46 of file gethex.c.

{
    Bigint* b;
    CONST unsigned char *decpt, *s0, *s, *s1;
    int esign, havedig, irv, k, n, nbits, up, zret;
    ULong L, lostbits, *x;
    Long e, e1;
#ifdef USE_LOCALE
    unsigned char decimalpoint = *localeconv()->decimal_point;
#else
#define decimalpoint '.'
#endif

    if(!hexdig['0'])
    {
        {
            hexdig_init_D2A();
        }
    }
    havedig = 0;
    s0 = *(CONST unsigned char**)sp + 2;
    while(s0[havedig] == '0')
    {
        {
            havedig++;
        }
    }
    s0 += havedig;
    s = s0;
    decpt = 0;
    zret = 0;
    e = 0;
    if(!hexdig[*s])
    {
        zret = 1;
        if(*s != decimalpoint)
        {
            {
                goto pcheck;
            }
        }
        decpt = ++s;
        if(!hexdig[*s])
        {
            {
                goto pcheck;
            }
        }
        while(*s == '0')
        {
            {
                s++;
            }
        }
        if(hexdig[*s])
        {
            {
                zret = 0;
            }
        }
        havedig = 1;
        s0 = s;
    }
    while(hexdig[*s])
    {
        {
            s++;
        }
    }
    if(*s == decimalpoint && !decpt)
    {
        decpt = ++s;
        while(hexdig[*s])
        {
            {
                s++;
            }
        }
    }
    if(decpt)
    {
        {
            e = -(((Long)(s - decpt)) << 2);
        }
    }
pcheck:
    s1 = s;
    switch(*s)
    {
        case 'p':
        case 'P':
            esign = 0;
            switch(*++s)
            {
                case '-':
                    esign = 1;
                    /* no break */
                case '+':
                    s++;
            }
            if((n = hexdig[*s]) == 0 || n > 0x19)
            {
                s = s1;
                break;
            }
            e1 = n - 0x10;
            while((n = hexdig[*++s]) != 0 && n <= 0x19)
            {
                {
                    e1 = 10 * e1 + n - 0x10;
                }
            }
            if(esign)
            {
                {
                    e1 = -e1;
                }
            }
            e += e1;
    }
    *sp = (const char*)s;
    if(zret)
    {
        if(!havedig)
        {
            {
                *sp = (const char*)s0 - 1;
            }
        }
        return STRTOG_Zero;
    }
    n = (int)(s1 - s0 - 1);
    for(k = 0; n > 7; n >>= 1)
    {
        {
            k++;
        }
    }
    b = Balloc(k);
    x = b->x;
    n = 0;
    L = 0;
    while(s1 > s0)
    {
        if(*--s1 == decimalpoint)
        {
            continue;
        }
        if(n == 32)
        {
            *x++ = L;
            L = 0;
            n = 0;
        }
        L |= (unsigned)((hexdig[*s1] & 0x0f) << n);
        n += 4;
    }
    *x++ = L;
    n = (int)(x - b->x);
    b->wds = n;
    n = 32 * n - hi0bits(L);
    nbits = fpi->nbits;
    lostbits = 0;
    x = b->x;
    if(n > nbits)
    {
        n -= nbits;
        if(any_on(b, n))
        {
            lostbits = 1;
            k = n - 1;
            if(x[k >> kshift] & 1 << (k & kmask))
            {
                lostbits = 2;
                if(k > 1 && any_on(b, k - 1))
                {
                    {
                        lostbits = 3;
                    }
                }
            }
        }
        rshift(b, n);
        e += n;
    }
    else if(n < nbits)
    {
        n = nbits - n;
        b = lshift(b, n);
        e -= n;
        x = b->x;
    }
    if(e > fpi->emax)
    {
    ovfl:
        Bfree(b);
        *bp = 0;
        return STRTOG_Infinite | STRTOG_Overflow | STRTOG_Inexhi;
    }
    irv = STRTOG_Normal;
    if(e < fpi->emin)
    {
        irv = STRTOG_Denormal;
        n = fpi->emin - e;
        if(n >= nbits)
        {
            switch(fpi->rounding)
            {
                case FPI_Round_near:
                    if(n == nbits && (n < 2 || any_on(b, n - 1)))
                    {
                        {
                            goto one_bit;
                        }
                    }
                    break;
                case FPI_Round_up:
                    if(!sign)
                    {
                        {
                            goto one_bit;
                        }
                    }
                    break;
                case FPI_Round_down:
                    if(sign)
                    {
                    one_bit:
                        *exp = fpi->emin;
                        x[0] = b->wds = 1;
                        *bp = b;
                        return STRTOG_Denormal | STRTOG_Inexhi | STRTOG_Underflow;
                    }
            }
            Bfree(b);
            *bp = 0;
            return STRTOG_Zero | STRTOG_Inexlo | STRTOG_Underflow;
        }
        k = n - 1;
        if(lostbits)
        {
            {
                lostbits = 1;
            }
        }
        else if(k > 0)
        {
            {
                lostbits = any_on(b, k);
            }
        }
        if(x[k >> kshift] & 1 << (k & kmask))
        {
            {
                lostbits |= 2;
            }
        }
        nbits -= n;
        rshift(b, n);
        e = fpi->emin;
    }
    if(lostbits)
    {
        up = 0;
        switch(fpi->rounding)
        {
            case FPI_Round_zero:
                break;
            case FPI_Round_near:
                if(lostbits & 2 && ((lostbits & 1) | (x[0] & 1)))
                {
                    {
                        up = 1;
                    }
                }
                break;
            case FPI_Round_up:
                up = 1 - sign;
                break;
            case FPI_Round_down:
                up = sign;
        }
        if(up)
        {
            k = b->wds;
            b = increment(b);
            x = b->x;
            if(irv == STRTOG_Denormal)
            {
                if(nbits == fpi->nbits - 1 && x[nbits >> kshift] & 1 << (nbits & kmask))
                {
                    {
                        irv = STRTOG_Normal;
                    }
                }
            }
            else if(b->wds > k || (((n = nbits & kmask) != 0) && (hi0bits(x[k - 1]) < (32 - n))))
            {
                rshift(b, 1);
                if(++e > fpi->emax)
                {
                    {
                        goto ovfl;
                    }
                }
            }
            irv |= STRTOG_Inexhi;
        }
        else
        {
            {
                irv |= STRTOG_Inexlo;
            }
        }
    }
    *bp = b;
    *exp = e;
    return irv;
}

References any_on(), Balloc(), Bfree(), CONST, lconv::decimal_point, decimalpoint, FPI::emax, FPI::emin, FPI_Round_down, FPI_Round_near, FPI_Round_up, FPI_Round_zero, hexdig, hexdig_init_D2A(), hi0bits, increment(), kmask, kshift, localeconv(), Long, lshift(), FPI::nbits, FPI::rounding, rshift(), STRTOG_Denormal, STRTOG_Inexhi, STRTOG_Inexlo, STRTOG_Infinite, STRTOG_Normal, STRTOG_Overflow, STRTOG_Underflow, STRTOG_Zero, Bigint::wds, and Bigint::x.

Referenced by strtod(), and strtodg().