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

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.