Return to atof1.c CVS log

Up to [Research Unix] / researchv10no / cmd / basic / bite / src

Annotation of researchv10no/cmd/basic/bite/src/atof1.c, revision 1.1

1.1     ! root        1: /* Copyright Bell Telephone Laboratories Whippany, N.J.
        !             2: 
        !             3:  *     ***********************************
        !             4:  *     ***********************************
        !             5:  *     **** ASCII TO FLOAT CONVERSION ****
        !             6:  *     *** R. B. Drake WH 8C-005 X4163 ***
        !             7:  *     **** Fri Aug 24 14:29:13 1979 *****
        !             8:  *     ***********************************
        !             9:  *     ***********************************
        !            10: 
        !            11: */
        !            12: /*   "@(#) atof1.c:  V 1.1  12/21/80" */
        !            13: 
        !            14: /*
        !            15: this is a more generalized version of atof. It is also written in "c"
        !            16: so that it can be compiled for the LSX system.
        !            17:  * CONVERT STRING TO FLOAT
        !            18:  */
        !            19: double atof1(s)
        !            20: char s[];
        !            21: {
        !            22:        register char *s1, *s2; /* string pointer regs */
        !            23:        register        i;      /* index register */
        !            24:        double val,power;
        !            25:        int sign,esin,exp;
        !            26: 
        !            27:        s1 = s;
        !            28:        s2 = s;
        !            29:        while(*s2 != '\0')
        !            30:                switch (*s2) {
        !            31:                        case ' ' :
        !            32:                        case '\015' :
        !            33:                        case '\012' :
        !            34:                        case '\t':
        !            35:                        s2++;
        !            36:                        break;
        !            37:                        case 'E':
        !            38:                        *s1++ = 'e';
        !            39:                        s2++;
        !            40:                        break;
        !            41:                        default:
        !            42:                        *s1++ = *s2++;
        !            43:                }
        !            44:        *s1 = '\0';
        !            45:        i=0;
        !            46:        sign = 1;
        !            47:        if(s[i] == '+' || s[i] == '-')
        !            48:                sign = (s[i++] == '+') ? 1 : -1 ;
        !            49:        for(val = 0;s[i] >= '0' && s[i] <= '9';i++)
        !            50:                val = 10 * val + s[i] - '0';
        !            51:        if(s[i] == '.')
        !            52:        {
        !            53:                i++;
        !            54:                for(power = 1;s[i] >= '0' && s[i] <= '9'; i++)
        !            55:                {
        !            56:                        val = val * 10 + s[i] - '0';
        !            57:                        power *= 10;
        !            58:                }
        !            59:                val /= power;
        !            60:        }
        !            61:        if(s[i] == 'e')
        !            62:        {
        !            63:                i++;
        !            64:                esin = 1;
        !            65:                if(s[i] == '+' || s[i] == '-')
        !            66:                        esin = (s[i++] == '+') ? 1 : -1;
        !            67:                for(exp = 0;s[i] >= '0' && s[i] <= '9';i++)
        !            68:                        exp = 10 * exp + s[i] - '0';
        !            69:                power = 1;
        !            70:                for(i=0;i<exp;i++)
        !            71:                        power *= 10;
        !            72:                val = (esin == -1) ? val/power : val * power ;
        !            73:        }
        !            74:        return(sign * val);
        !            75: }

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