home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / GCC / GERLIB_DEV08B.LHA / gerlib / string / normal / strtod.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-12  |  4.9 KB  |  160 lines
  1. #include <string.h>
  2. #include <stddef.h>
  3. #include <errno.h>
  4.  
  5. /*  File   : str2dbl.c
  6.     Author : Richard A. O'Keefe @ Quintus Computer Systems, Inc.
  7.     Updated: Tuesday August 2nd, 1988
  8.     Defines: double str2dbl(char *str, char**ptr)
  9. */
  10.  
  11. /*  This is an implementation of the strtod() function described in the 
  12.     System V manuals, with a different name to avoid linker problems.
  13.     All that str2dbl() does itself is check that the argument is well-formed
  14.     and is in range.  It leaves the work of conversion to atof(), which is
  15.     assumed to exist and deliver correct results (if they can be represented).
  16.  
  17.     There are two reasons why this should be provided to the net:
  18.     (a) some UNIX systems do not yet have strtod(), or do not have it
  19.         available in the BSD "universe" (but they do have atof()).
  20.     (b) some of the UNIX systems that *do* have it get it wrong.
  21.     (some crash with large arguments, some assign the wrong *ptr value).
  22.     There is a reason why *we* are providing it: we need a correct version
  23.     of strtod(), and if we give this one away maybe someone will look for
  24.     mistakes in it and fix them for us (:-).
  25. */
  26.     
  27. /*  The following constants are machine-specific.  MD{MIN,MAX}EXPT are
  28.     integers and MD{MIN,MAX}FRAC are strings such that
  29.     0.${MDMAXFRAC}e${MDMAXEXPT} is the largest representable double,
  30.     0.${MDMINFRAC}e${MDMINEXPT} is the smallest representable +ve double
  31.     MD{MIN,MAX}FRAC must not have any trailing zeros.
  32.     The values here are for IEEE-754 64-bit floats.
  33.     It is not perfectly clear to me whether an IEEE infinity should be
  34.     returned for overflow, nor what a portable way of writing one is,
  35.     so HUGE is just 0.MAXFRAC*10**MAXEXPT (this seems still to be the
  36.     UNIX convention).
  37.  
  38.     I do know about <values.h>, but the whole point of this file is that
  39.     we can't always trust that stuff to be there or to be correct.
  40. */
  41.  
  42.  
  43. /* Changed the name to be really stdtod() in my library. mw */
  44.  
  45. /* #define KERNEL
  46. #include "ixemul.h" */
  47.  
  48. static    int    MDMINEXPT    = {-323};
  49. static    char    MDMINFRAC[]    = "494065645841246544";
  50. static    double    ZERO        = 0.0;
  51.  
  52. static    int    MDMAXEXPT    = { 309};
  53. static    char    MDMAXFRAC[]    = "17976931348623147";
  54. #ifndef amigados
  55. static    double    HUGE        = 1.7976931348623147e308;
  56. #else
  57. /* my library can't handle that boundery condition yet.. */
  58. #define    HUGE            (*(double *)(unsigned long []){0x7fefffff, 0xffffffff})
  59. #endif
  60.  
  61. extern    double    atof();        /* Only called when result known to be ok */
  62.  
  63. double strtod(str, ptr)
  64.     char *str;
  65.     char **ptr;
  66.     {
  67.     int sign, scale, dotseen;
  68.     int esign, expt;
  69.     char *save;
  70.     register char *sp, *dp;
  71.     register int c;
  72.     char *buforg, *buflim;
  73.     char buffer[64];        /* 45-digit significand + */
  74.                     /* 13-digit exponent */
  75.     sp = str;
  76.     while (*sp == ' ') sp++;
  77.     sign = 1;
  78.     if (*sp == '-') sign -= 2, sp++;
  79.     dotseen = 0, scale = 0;
  80.     dp = buffer;    
  81.     *dp++ = '0'; *dp++ = '.';
  82.     buforg = dp, buflim = buffer+48;
  83.     for (save = sp; c = *sp; sp++)
  84.         if (c == '.') {
  85.         if (dotseen) break;
  86.         dotseen++;
  87.         } else
  88.         if ((unsigned)(c-'0') > (unsigned)('9'-'0')) {
  89.         break;
  90.         } else
  91.         if (c == '0') {
  92.         if (dp != buforg) {
  93.             /* This is not the first digit, so we want to keep it */
  94.             if (dp < buflim) *dp++ = c;
  95.         } else {
  96.             /* No non-zero digits seen yet */
  97.             /* If a . has been seen, scale must be adjusted */
  98.             if (dotseen) scale--;
  99.         }
  100.         } else {
  101.         /* This is a nonzero digit, so we want to keep it */
  102.         if (dp < buflim) *dp++ = c;
  103.         /* If it precedes a ., scale must be adjusted */
  104.         if (!dotseen) scale++;
  105.         }
  106.     if (sp == save) {
  107.         if (ptr) *ptr = str;
  108.         errno = EDOM;        /* what should this be? */
  109.         return ZERO;
  110.     }
  111.     
  112.     while (dp > buforg && dp[-1] == '0') --dp;
  113.     if (dp == buforg) *dp++ = '0';
  114.     *dp = '\0';
  115.     /*  Now the contents of buffer are
  116.         +--+--------+-+--------+
  117.         |0.|fraction|\|leftover|
  118.         +--+--------+-+--------+
  119.              ^dp points here
  120.         where fraction begins with 0 iff it is "0", and has at most
  121.         45 digits in it, and leftover is at least 16 characters.
  122.     */
  123.     save = sp, expt = 0, esign = 1;
  124.     do {
  125.         c = *sp++;
  126.         if (c != 'e' && c != 'E') break;
  127.         c = *sp++;
  128.         if (c == '-') esign -= 2, c = *sp++; else
  129.         if (c == '+' || c == ' ') c = *sp++;
  130.         if ((unsigned)(c-'0') > (unsigned)('9'-'0')) break;
  131.         while (c == '0') c = *sp++;
  132.         for (; (unsigned)(c-'0') <= (unsigned)('9'-'0'); c = *sp++)
  133.         expt = expt*10 + c-'0';        
  134.         if (esign < 0) expt = -expt;
  135.         save = sp-1;
  136.     } while (0);
  137.     if (ptr) *ptr = save;
  138.     expt += scale;
  139.     /*  Now the number is sign*0.fraction*10**expt  */
  140.     errno = ERANGE;
  141.     if (expt > MDMAXEXPT) {
  142.         return HUGE*sign;
  143.     } else
  144.     if (expt == MDMAXEXPT) {
  145.         if (strcmp(buforg, MDMAXFRAC) > 0) return HUGE*sign;
  146.     } else
  147.     if (expt < MDMINEXPT) {
  148.         return ZERO*sign;
  149.     } else
  150.     if (expt == MDMINEXPT) {
  151.         if (strcmp(buforg, MDMINFRAC) < 0) return ZERO*sign;
  152.     }
  153.     /*  We have now established that the number can be  */
  154.     /*  represented without overflow or underflow  */
  155.     (void) sprintf(dp, "E%d", expt);
  156.     errno = 0;
  157.     return atof(buffer)*sign;
  158.     }
  159.  
  160.