Return to atof.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ingres / source / gutil

Annotation of 43BSD/ingres/source/gutil/atof.c, revision 1.1.1.1

1.1       root        1: # include      <sccs.h>
                      2: 
                      3: SCCSID(@(#)atof.c      8.1     12/31/84)
                      4: 
                      5: /*
                      6: **  ATOF -- ASCII TO FLOATING CONVERSION
                      7: **
                      8: **     Converts the string 'str' to floating point and stores the
                      9: **     result into the cell pointed to by 'val'.
                     10: **
                     11: **     The syntax which it accepts is pretty much what you would
                     12: **     expect.  Basically, it is:
                     13: **             {<sp>} [+|-] {<sp>} {<digit>} [.{digit}] {<sp>} [<exp>]
                     14: **     where <exp> is "e" or "E" followed by an integer, <sp> is a
                     15: **     space character, <digit> is zero through nine, [] is zero or
                     16: **     one, and {} is zero or more.
                     17: **
                     18: **     Parameters:
                     19: **             str -- string to convert.
                     20: **             val -- pointer to place to put the result (which
                     21: **                     must be type double).
                     22: **
                     23: **     Returns:
                     24: **             zero -- ok.
                     25: **             -1 -- syntax error.
                     26: **             +1 -- overflow (someday).
                     27: **
                     28: **     Side Effects:
                     29: **             clobbers *val.
                     30: */
                     31: 
                     32: atof(str, val)
                     33: char   *str;
                     34: double *val;
                     35: {
                     36:        register char   *p;
                     37:        double          v;
                     38:        extern double   pow();
                     39:        double          fact;
                     40:        int             minus;
                     41:        register char   c;
                     42:        int             expon;
                     43:        register int    gotmant;
                     44: 
                     45:        v = 0.0;
                     46:        p = str;
                     47:        minus = 0;
                     48: 
                     49:        /* skip leading blanks */
                     50:        while (c = *p)
                     51:        {
                     52:                if (c != ' ')
                     53:                        break;
                     54:                p++;
                     55:        }
                     56: 
                     57:        /* handle possible sign */
                     58:        switch (c)
                     59:        {
                     60: 
                     61:          case '-':
                     62:                minus++;
                     63: 
                     64:          case '+':
                     65:                p++;
                     66: 
                     67:        }
                     68: 
                     69:        /* skip blanks after sign */
                     70:        while (c = *p)
                     71:        {
                     72:                if (c != ' ')
                     73:                        break;
                     74:                p++;
                     75:        }
                     76: 
                     77:        /* start collecting the number to the decimal point */
                     78:        gotmant = 0;
                     79:        for (;;)
                     80:        {
                     81:                c = *p;
                     82:                if (c < '0' || c > '9')
                     83:                        break;
                     84:                v = v * 10.0 + (c - '0');
                     85:                gotmant++;
                     86:                p++;
                     87:        }
                     88: 
                     89:        /* check for fractional part */
                     90:        if (c == '.')
                     91:        {
                     92:                fact = 1.0;
                     93:                for (;;)
                     94:                {
                     95:                        c = *++p;
                     96:                        if (c < '0' || c > '9')
                     97:                                break;
                     98:                        fact *= 0.1;
                     99:                        v += (c - '0') * fact;
                    100:                        gotmant++;
                    101:                }
                    102:        }
                    103: 
                    104:        /* skip blanks before possible exponent */
                    105:        while (c = *p)
                    106:        {
                    107:                if (c != ' ')
                    108:                        break;
                    109:                p++;
                    110:        }
                    111: 
                    112:        /* test for exponent */
                    113:        if (c == 'e' || c == 'E')
                    114:        {
                    115:                p++;
                    116:                expon = atoi(p);
                    117:                if (!gotmant)
                    118:                        v = 1.0;
                    119:                fact = expon;
                    120:                v *= pow(10.0, fact);
                    121:        }
                    122:        else
                    123:        {
                    124:                /* if no exponent, then nothing */
                    125:                if (c != 0)
                    126:                        return (-1);
                    127:        }
                    128: 
                    129:        /* store the result and exit */
                    130:        if (minus)
                    131:                v = -v;
                    132:        *val = v;
                    133:        return (0);
                    134: }

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