|
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 */ |
|
47 static int MDMINEXPT = -323; |
|
48 static char MDMINFRAC[] = "494065645841246544"; |
|
49 static double ZERO = 0.0; |
|
50 |
|
51 static int MDMAXEXPT = 309; |
|
52 static char MDMAXFRAC[] = "17976931348623157"; |
|
53 static double HUGE = 1.7976931348623157e308; |
|
54 |
|
55 extern double atof(const char *); /* Only called when result known to be ok */ |
|
56 |
|
57 #ifdef HAVE_ERRNO_H |
|
58 #include <errno.h> |
|
59 #endif |
|
60 extern int errno; |
|
61 |
|
62 double 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 } |