Return to atof.c CVS log

Up to [MW Coherent from dump] / coherent / b / lib / libc / gen

Annotation of coherent/b/lib/libc/gen/atof.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * /usr/src/libc/gen/atof.c
                      3:  * C general utilities library.
                      4:  * atof()
                      5:  * ANSI 4.10.1.1.
                      6:  * Convert ASCII to double (the old fashioned way).
                      7:  * Builds significand in an unsigned long, for efficiency.
                      8:  * Does not use any knowledge about floating point representation.
                      9:  */
                     10: 
                     11: #if    __STDC__
                     12: #include <stdlib.h>
                     13: #include <limits.h>
                     14: #include <locale.h>
                     15: #else
                     16: #define        _decimal_point  '.'
                     17: extern double  _pow10();
                     18: #endif
                     19: #include <ctype.h>
                     20: 
                     21: /* Flag bits. */
                     22: #define        NEG     1                       /* negative significand */
                     23: #define        DOT     2                       /* decimal point seen   */
                     24: #define        NEGEXP  4                       /* negative exponent    */
                     25: #define        BIG     8                       /* significand too big for ulong */
                     26: 
                     27: double
                     28: atof(nptr) register char *nptr;
                     29: {
                     30:        register int            c, flag, eexp;
                     31:        register unsigned long  val;
                     32:        int                     exp, vdigits;
                     33:        double                  d;
                     34: 
                     35:        val = flag = exp = vdigits = 0;
                     36: 
                     37:        /* Leading white space. */
                     38:        while (isspace(c = *nptr++))
                     39:                ;
                     40: 
                     41:        /* Optional sign. */
                     42:        switch (c) {
                     43:        case '-':
                     44:                flag |= NEG;
                     45:        case '+':
                     46:                c = *nptr++;
                     47:        }
                     48: 
                     49:        /* Number: sequence of decimal digits with optional '.'. */
                     50:        for (; ; c = *nptr++) {
                     51:                if (isdigit(c)) {
                     52:                        c -= '0';
                     53:                        if (c == 0 && (flag & DOT)) {
                     54:                                /* Check for trailing zeros to avoid imprecision. */
                     55:                                char *look, d;
                     56: 
                     57:                                for (look = nptr; (d = *look++) == '0'; )
                     58:                                        ;               /* skip a trailing zero */
                     59:                                if (!isdigit(d)) {      /* ignore zeroes */
                     60:                                        nptr = look;
                     61:                                        c = d;
                     62:                                        break;
                     63:                                }                       /* else don't ignore */
                     64:                        }
                     65: #if    __STDC__
                     66:                        if (val > (ULONG_MAX-9) / 10) {
                     67: #else
                     68:                        /* The pre-ANSI compiler gets the test above wrong. */
                     69:                        if (val > 429496728L) {
                     70: #endif
                     71:                                /* Significand too big for val, use d. */
                     72:                                if (flag & BIG)
                     73:                                        d = d * _pow10(vdigits) + val;  
                     74:                                else {
                     75:                                        d = val;
                     76:                                        flag |= BIG;
                     77:                                }
                     78:                                vdigits = 1;
                     79:                                val = c;
                     80:                        } else {
                     81:                                ++vdigits;      /* decimal digits in val */
                     82:                                /* val = val * 10 + c; */
                     83:                                val <<= 1;
                     84:                                val = val + (val << 2) + c;
                     85:                        }
                     86:                        if (flag & DOT)
                     87:                                --exp;
                     88:                } else if (c == _decimal_point && (flag & DOT) == 0)
                     89:                        flag |= DOT;
                     90:                else
                     91:                        break;
                     92:        }
                     93:        if (flag & BIG)
                     94:                d = d * _pow10(vdigits) + val;
                     95:        else
                     96:                d = val;
                     97: 
                     98:        /* Optional exponent: 'E' or 'e', optional sign, decimal digits. */
                     99:        if (c == 'e'  ||  c == 'E') {
                    100: 
                    101:                /* Optional sign. */
                    102:                switch (c = *nptr++) {
                    103:                case '-':
                    104:                        flag |= NEGEXP;
                    105:                case '+':
                    106:                        c = *nptr++;
                    107:                }
                    108: 
                    109:                /* Decimal digits. */
                    110:                for (eexp = 0; isdigit(c); c = *nptr++)
                    111:                        eexp = eexp * 10 + c - '0';
                    112: 
                    113:                /* Adjust explicit exponent for digits read after '.'. */
                    114:                if (flag & NEGEXP)
                    115:                        exp -= eexp;
                    116:                else
                    117:                        exp += eexp;
                    118:        }
                    119: 
                    120:        /* Reconcile the significand with the exponent and sign. */
                    121:        if (exp != 0)
                    122:                d *= _pow10(exp);
                    123:        return ((flag & NEG) ? -d : d);
                    124: }
                    125: 
                    126: /* end of libc/gen/atof.c */

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