Return to atof.c CVS log

Up to [Research Unix] / researchv9 / libc / gen

Annotation of researchv9/libc/gen/atof.c, revision 1.1

1.1     ! root        1: /*LINTLIBRARY*/
        !             2: /*
        !             3:  *     C library - ascii to floating
        !             4:  */
        !             5: 
        !             6: #include <ctype.h>
        !             7: 
        !             8: double
        !             9: atof(p)
        !            10: register char *p;
        !            11: {
        !            12:        register c;
        !            13:        double fl, flexp, exp5;
        !            14:        double big = 72057594037927936.;  /*2^56*/
        !            15:        double ldexp();
        !            16:        register eexp, exp, neg, negexp, bexp;
        !            17: 
        !            18:        neg = 1;
        !            19:        while(isspace(*p))
        !            20:                ++p;
        !            21:        if(*p == '-') {
        !            22:                ++p;
        !            23:                neg = -1;
        !            24:        }
        !            25:        else if(*p == '+')
        !            26:                ++p;
        !            27: 
        !            28:        exp = 0;
        !            29:        fl = 0;
        !            30:        while((c = *p++), isdigit(c))
        !            31:                if(fl < big)
        !            32:                        fl = 10*fl + (c-'0');
        !            33:                else
        !            34:                        exp++;
        !            35: 
        !            36:        if(c == '.')
        !            37:                while((c = *p++), isdigit(c))
        !            38:                        if(fl < big) {
        !            39:                                fl = 10*fl + (c-'0');
        !            40:                                exp--;
        !            41:                        }
        !            42: 
        !            43:        negexp = 1;
        !            44:        eexp = 0;
        !            45:        if((c == 'E') || (c == 'e')) {
        !            46:                if((c = *p++) == '+')
        !            47:                        ;
        !            48:                else if(c == '-')
        !            49:                        negexp = -1;
        !            50:                     else
        !            51:                        --p;
        !            52: 
        !            53:                while((c = *p++), isdigit(c))
        !            54:                        eexp = 10*eexp + (c-'0');
        !            55: 
        !            56:                if(negexp < 0)
        !            57:                        eexp = -eexp;
        !            58:                exp = exp + eexp;
        !            59:        }
        !            60: 
        !            61:        negexp = 1;
        !            62:        if(exp < 0) {
        !            63:                negexp = -1;
        !            64:                exp = -exp;
        !            65:        }
        !            66: 
        !            67:        flexp = 1;
        !            68:        exp5 = 5;
        !            69:        bexp = exp;
        !            70:        while(1) {
        !            71:                if(exp&01)
        !            72:                        flexp *= exp5;
        !            73:                exp >>= 1;
        !            74:                if(exp == 0)
        !            75:                        break;
        !            76:                exp5 *= exp5;
        !            77:        }
        !            78:        if(negexp < 0)
        !            79:                fl /= flexp;
        !            80:        else
        !            81:                fl *= flexp;
        !            82:        fl = ldexp(fl, negexp*bexp);
        !            83:        if(neg < 0)
        !            84:                fl = -fl;
        !            85:        return(fl);
        !            86: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.