From 23d5cdebacba5488dbb97fbe2f776d3fcd35432f Mon Sep 17 00:00:00 2001 From: Guido van Rossum Date: Tue, 14 Jan 1992 18:42:23 +0000 Subject: [PATCH] New version from the net. --- Python/strtod.c | 166 +++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 149 insertions(+), 17 deletions(-) diff --git a/Python/strtod.c b/Python/strtod.c index e3fb81b921b..675de30efc8 100644 --- a/Python/strtod.c +++ b/Python/strtod.c @@ -1,22 +1,154 @@ -/* This is not a proper strtod() implementation, but sufficient for Python. - Python won't detect floating point constant overflow, though. */ +/* comp.sources.misc strtod(), as posted in comp.lang.tcl, + with bugfix for "123000.0" and acceptance of space after 'e' sign nuked. -extern int errno; + ************************************************************ + * YOU MUST EDIT THE MACHINE-DEPENDENT DEFINITIONS BELOW!!! * + ************************************************************ +*/ -extern int strlen(); -extern double atof(); +/* File : stdtod.c (Modified version of str2dbl.c) + Author : Richard A. O'Keefe @ Quintus Computer Systems, Inc. + Updated: Tuesday August 2nd, 1988 + Defines: double strtod (char *str, char**ptr) +*/ -double -strtod(p, pp) - char *p; - char **pp; -{ - double res; +/* This is an implementation of the strtod() function described in the + System V manuals, with a different name to avoid linker problems. + All that str2dbl() does itself is check that the argument is well-formed + and is in range. It leaves the work of conversion to atof(), which is + assumed to exist and deliver correct results (if they can be represented). - if (pp) - *pp = p + strlen(p); - res = atof(p); - errno = 0; - return res; + There are two reasons why this should be provided to the net: + (a) some UNIX systems do not yet have strtod(), or do not have it + available in the BSD "universe" (but they do have atof()). + (b) some of the UNIX systems that *do* have it get it wrong. + (some crash with large arguments, some assign the wrong *ptr value). + There is a reason why *we* are providing it: we need a correct version + of strtod(), and if we give this one away maybe someone will look for + mistakes in it and fix them for us (:-). +*/ + +/* The following constants are machine-specific. MD{MIN,MAX}EXPT are + integers and MD{MIN,MAX}FRAC are strings such that + 0.${MDMAXFRAC}e${MDMAXEXPT} is the largest representable double, + 0.${MDMINFRAC}e${MDMINEXPT} is the smallest representable +ve double + MD{MIN,MAX}FRAC must not have any trailing zeros. + The values here are for IEEE-754 64-bit floats. + It is not perfectly clear to me whether an IEEE infinity should be + returned for overflow, nor what a portable way of writing one is, + so HUGE is just 0.MAXFRAC*10**MAXEXPT (this seems still to be the + UNIX convention). + + I do know about , but the whole point of this file is that + we can't always trust that stuff to be there or to be correct. +*/ +static int MDMINEXPT = {-323}; +static char MDMINFRAC[] = "494065645841246544"; +static double ZERO = 0.0; + +static int MDMAXEXPT = { 309}; +static char MDMAXFRAC[] = "17976931348623147"; +static double HUGE = 1.7976931348623147e308; + +extern double atof(); /* Only called when result known to be ok */ + +#include +extern int errno; + +double strtod(str, ptr) + char *str; + char **ptr; + { + int sign, scale, dotseen; + int esign, expt; + char *save; + register char *sp, *dp; + register int c; + char *buforg, *buflim; + char buffer[64]; /* 45-digit significand + */ + /* 13-digit exponent */ + sp = str; + while (*sp == ' ') sp++; + sign = 1; + if (*sp == '-') sign -= 2, sp++; + dotseen = 0, scale = 0; + dp = buffer; + *dp++ = '0'; *dp++ = '.'; + buforg = dp, buflim = buffer+48; + for (save = sp; c = *sp; sp++) + if (c == '.') { + if (dotseen) break; + dotseen++; + } else + if ((unsigned)(c-'0') > (unsigned)('9'-'0')) { + break; + } else + if (c == '0') { + if (dp != buforg) { + /* This is not the first digit, so we want to keep it */ + if (dp < buflim) *dp++ = c; + if (!dotseen) scale++; + } else { + /* No non-zero digits seen yet */ + /* If a . has been seen, scale must be adjusted */ + if (dotseen) scale--; + } + } else { + /* This is a nonzero digit, so we want to keep it */ + if (dp < buflim) *dp++ = c; + /* If it precedes a ., scale must be adjusted */ + if (!dotseen) scale++; + } + if (sp == save) { + if (ptr) *ptr = str; + errno = EDOM; /* what should this be? */ + return ZERO; + } -} + while (dp > buforg && dp[-1] == '0') --dp; + if (dp == buforg) *dp++ = '0'; + *dp = '\0'; + /* Now the contents of buffer are + +--+--------+-+--------+ + |0.|fraction|\|leftover| + +--+--------+-+--------+ + ^dp points here + where fraction begins with 0 iff it is "0", and has at most + 45 digits in it, and leftover is at least 16 characters. + */ + save = sp, expt = 0, esign = 1; + do { + c = *sp++; + if (c != 'e' && c != 'E') break; + c = *sp++; + if (c == '-') esign -= 2, c = *sp++; else + if (c == '+' /* || c == ' ' */ ) c = *sp++; + if ((unsigned)(c-'0') > (unsigned)('9'-'0')) break; + while (c == '0') c = *sp++; + for (; (unsigned)(c-'0') <= (unsigned)('9'-'0'); c = *sp++) + expt = expt*10 + c-'0'; + if (esign < 0) expt = -expt; + save = sp-1; + } while (0); + if (ptr) *ptr = save; + expt += scale; + /* Now the number is sign*0.fraction*10**expt */ + errno = ERANGE; + if (expt > MDMAXEXPT) { + return HUGE*sign; + } else + if (expt == MDMAXEXPT) { + if (strcmp(buforg, MDMAXFRAC) > 0) return HUGE*sign; + } else + if (expt < MDMINEXPT) { + return ZERO*sign; + } else + if (expt == MDMINEXPT) { + if (strcmp(buforg, MDMINFRAC) < 0) return ZERO*sign; + } + /* We have now established that the number can be */ + /* represented without overflow or underflow */ + (void) sprintf(dp, "E%d", expt); + errno = 0; + return atof(buffer)*sign; + }