PageRenderTime 14ms CodeModel.GetById 2ms app.highlight 10ms RepoModel.GetById 1ms app.codeStats 0ms

/Python/strtod.c

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