| Location | Tool | Test ID | Function | Issue |
|---|---|---|---|---|
| /builddir/build/BUILD/Python-2.7.3/Python/pystrtod.c:1008:13 | clang-analyzer | Value stored to 'p' is never read | ||
| /builddir/build/BUILD/Python-2.7.3/Python/pystrtod.c:1173:0 | cppcheck | nullPointer | Possible null pointer dereference: p | |
| /builddir/build/BUILD/Python-2.7.3/Python/pystrtod.c:1173:0 | cppcheck | nullPointer | Possible null pointer dereference: p |
1 /* -*- Mode: C; c-file-style: "python" -*- */
2
3 #include <Python.h>
4 #include <locale.h>
5
6 /* Case-insensitive string match used for nan and inf detection; t should be
7 lower-case. Returns 1 for a successful match, 0 otherwise. */
8
9 static int
10 case_insensitive_match(const char *s, const char *t)
11 {
12 while(*t && Py_TOLOWER(*s) == *t) {
13 s++;
14 t++;
15 }
16 return *t ? 0 : 1;
17 }
18
19 /* _Py_parse_inf_or_nan: Attempt to parse a string of the form "nan", "inf" or
20 "infinity", with an optional leading sign of "+" or "-". On success,
21 return the NaN or Infinity as a double and set *endptr to point just beyond
22 the successfully parsed portion of the string. On failure, return -1.0 and
23 set *endptr to point to the start of the string. */
24
25 double
26 _Py_parse_inf_or_nan(const char *p, char **endptr)
27 {
28 double retval;
29 const char *s;
30 int negate = 0;
31
32 s = p;
33 if (*s == '-') {
34 negate = 1;
35 s++;
36 }
37 else if (*s == '+') {
38 s++;
39 }
40 if (case_insensitive_match(s, "inf")) {
41 s += 3;
42 if (case_insensitive_match(s, "inity"))
43 s += 5;
44 retval = negate ? -Py_HUGE_VAL : Py_HUGE_VAL;
45 }
46 #ifdef Py_NAN
47 else if (case_insensitive_match(s, "nan")) {
48 s += 3;
49 retval = negate ? -Py_NAN : Py_NAN;
50 }
51 #endif
52 else {
53 s = p;
54 retval = -1.0;
55 }
56 *endptr = (char *)s;
57 return retval;
58 }
59
60 /**
61 * PyOS_ascii_strtod:
62 * @nptr: the string to convert to a numeric value.
63 * @endptr: if non-%NULL, it returns the character after
64 * the last character used in the conversion.
65 *
66 * Converts a string to a #gdouble value.
67 * This function behaves like the standard strtod() function
68 * does in the C locale. It does this without actually
69 * changing the current locale, since that would not be
70 * thread-safe.
71 *
72 * This function is typically used when reading configuration
73 * files or other non-user input that should be locale independent.
74 * To handle input from the user you should normally use the
75 * locale-sensitive system strtod() function.
76 *
77 * If the correct value would cause overflow, plus or minus %HUGE_VAL
78 * is returned (according to the sign of the value), and %ERANGE is
79 * stored in %errno. If the correct value would cause underflow,
80 * zero is returned and %ERANGE is stored in %errno.
81 * If memory allocation fails, %ENOMEM is stored in %errno.
82 *
83 * This function resets %errno before calling strtod() so that
84 * you can reliably detect overflow and underflow.
85 *
86 * Return value: the #gdouble value.
87 **/
88
89 #ifndef PY_NO_SHORT_FLOAT_REPR
90
91 double
92 _PyOS_ascii_strtod(const char *nptr, char **endptr)
93 {
94 double result;
95 _Py_SET_53BIT_PRECISION_HEADER;
96
97 assert(nptr != NULL);
98 /* Set errno to zero, so that we can distinguish zero results
99 and underflows */
100 errno = 0;
101
102 _Py_SET_53BIT_PRECISION_START;
103 result = _Py_dg_strtod(nptr, endptr);
104 _Py_SET_53BIT_PRECISION_END;
105
106 if (*endptr == nptr)
107 /* string might represent an inf or nan */
108 result = _Py_parse_inf_or_nan(nptr, endptr);
109
110 return result;
111
112 }
113
114 #else
115
116 /*
117 Use system strtod; since strtod is locale aware, we may
118 have to first fix the decimal separator.
119
120 Note that unlike _Py_dg_strtod, the system strtod may not always give
121 correctly rounded results.
122 */
123
124 double
125 _PyOS_ascii_strtod(const char *nptr, char **endptr)
126 {
127 char *fail_pos;
128 double val = -1.0;
129 struct lconv *locale_data;
130 const char *decimal_point;
131 size_t decimal_point_len;
132 const char *p, *decimal_point_pos;
133 const char *end = NULL; /* Silence gcc */
134 const char *digits_pos = NULL;
135 int negate = 0;
136
137 assert(nptr != NULL);
138
139 fail_pos = NULL;
140
141 locale_data = localeconv();
142 decimal_point = locale_data->decimal_point;
143 decimal_point_len = strlen(decimal_point);
144
145 assert(decimal_point_len != 0);
146
147 decimal_point_pos = NULL;
148
149 /* Parse infinities and nans */
150 val = _Py_parse_inf_or_nan(nptr, endptr);
151 if (*endptr != nptr)
152 return val;
153
154 /* Set errno to zero, so that we can distinguish zero results
155 and underflows */
156 errno = 0;
157
158 /* We process the optional sign manually, then pass the remainder to
159 the system strtod. This ensures that the result of an underflow
160 has the correct sign. (bug #1725) */
161 p = nptr;
162 /* Process leading sign, if present */
163 if (*p == '-') {
164 negate = 1;
165 p++;
166 }
167 else if (*p == '+') {
168 p++;
169 }
170
171 /* Some platform strtods accept hex floats; Python shouldn't (at the
172 moment), so we check explicitly for strings starting with '0x'. */
173 if (*p == '0' && (*(p+1) == 'x' || *(p+1) == 'X'))
174 goto invalid_string;
175
176 /* Check that what's left begins with a digit or decimal point */
177 if (!Py_ISDIGIT(*p) && *p != '.')
178 goto invalid_string;
179
180 digits_pos = p;
181 if (decimal_point[0] != '.' ||
182 decimal_point[1] != 0)
183 {
184 /* Look for a '.' in the input; if present, it'll need to be
185 swapped for the current locale's decimal point before we
186 call strtod. On the other hand, if we find the current
187 locale's decimal point then the input is invalid. */
188 while (Py_ISDIGIT(*p))
189 p++;
190
191 if (*p == '.')
192 {
193 decimal_point_pos = p++;
194
195 /* locate end of number */
196 while (Py_ISDIGIT(*p))
197 p++;
198
199 if (*p == 'e' || *p == 'E')
200 p++;
201 if (*p == '+' || *p == '-')
202 p++;
203 while (Py_ISDIGIT(*p))
204 p++;
205 end = p;
206 }
207 else if (strncmp(p, decimal_point, decimal_point_len) == 0)
208 /* Python bug #1417699 */
209 goto invalid_string;
210 /* For the other cases, we need not convert the decimal
211 point */
212 }
213
214 if (decimal_point_pos) {
215 char *copy, *c;
216 /* Create a copy of the input, with the '.' converted to the
217 locale-specific decimal point */
218 copy = (char *)PyMem_MALLOC(end - digits_pos +
219 1 + decimal_point_len);
220 if (copy == NULL) {
221 *endptr = (char *)nptr;
222 errno = ENOMEM;
223 return val;
224 }
225
226 c = copy;
227 memcpy(c, digits_pos, decimal_point_pos - digits_pos);
228 c += decimal_point_pos - digits_pos;
229 memcpy(c, decimal_point, decimal_point_len);
230 c += decimal_point_len;
231 memcpy(c, decimal_point_pos + 1,
232 end - (decimal_point_pos + 1));
233 c += end - (decimal_point_pos + 1);
234 *c = 0;
235
236 val = strtod(copy, &fail_pos);
237
238 if (fail_pos)
239 {
240 if (fail_pos > decimal_point_pos)
241 fail_pos = (char *)digits_pos +
242 (fail_pos - copy) -
243 (decimal_point_len - 1);
244 else
245 fail_pos = (char *)digits_pos +
246 (fail_pos - copy);
247 }
248
249 PyMem_FREE(copy);
250
251 }
252 else {
253 val = strtod(digits_pos, &fail_pos);
254 }
255
256 if (fail_pos == digits_pos)
257 goto invalid_string;
258
259 if (negate && fail_pos != nptr)
260 val = -val;
261 *endptr = fail_pos;
262
263 return val;
264
265 invalid_string:
266 *endptr = (char*)nptr;
267 errno = EINVAL;
268 return -1.0;
269 }
270
271 #endif
272
273 /* PyOS_ascii_strtod is DEPRECATED in Python 2.7 and 3.1 */
274
275 double
276 PyOS_ascii_strtod(const char *nptr, char **endptr)
277 {
278 char *fail_pos;
279 const char *p;
280 double x;
281
282 if (PyErr_WarnEx(PyExc_DeprecationWarning,
283 "PyOS_ascii_strtod and PyOS_ascii_atof are "
284 "deprecated. Use PyOS_string_to_double "
285 "instead.", 1) < 0)
286 return -1.0;
287
288 /* _PyOS_ascii_strtod already does everything that we want,
289 except that it doesn't parse leading whitespace */
290 p = nptr;
291 while (Py_ISSPACE(*p))
292 p++;
293 x = _PyOS_ascii_strtod(p, &fail_pos);
294 if (fail_pos == p)
295 fail_pos = (char *)nptr;
296 if (endptr)
297 *endptr = (char *)fail_pos;
298 return x;
299 }
300
301 /* PyOS_ascii_strtod is DEPRECATED in Python 2.7 and 3.1 */
302
303 double
304 PyOS_ascii_atof(const char *nptr)
305 {
306 return PyOS_ascii_strtod(nptr, NULL);
307 }
308
309 /* PyOS_string_to_double is the recommended replacement for the deprecated
310 PyOS_ascii_strtod and PyOS_ascii_atof functions. It converts a
311 null-terminated byte string s (interpreted as a string of ASCII characters)
312 to a float. The string should not have leading or trailing whitespace (in
313 contrast, PyOS_ascii_strtod allows leading whitespace but not trailing
314 whitespace). The conversion is independent of the current locale.
315
316 If endptr is NULL, try to convert the whole string. Raise ValueError and
317 return -1.0 if the string is not a valid representation of a floating-point
318 number.
319
320 If endptr is non-NULL, try to convert as much of the string as possible.
321 If no initial segment of the string is the valid representation of a
322 floating-point number then *endptr is set to point to the beginning of the
323 string, -1.0 is returned and again ValueError is raised.
324
325 On overflow (e.g., when trying to convert '1e500' on an IEEE 754 machine),
326 if overflow_exception is NULL then +-Py_HUGE_VAL is returned, and no Python
327 exception is raised. Otherwise, overflow_exception should point to a
328 a Python exception, this exception will be raised, -1.0 will be returned,
329 and *endptr will point just past the end of the converted value.
330
331 If any other failure occurs (for example lack of memory), -1.0 is returned
332 and the appropriate Python exception will have been set.
333 */
334
335 double
336 PyOS_string_to_double(const char *s,
337 char **endptr,
338 PyObject *overflow_exception)
339 {
340 double x, result=-1.0;
341 char *fail_pos;
342
343 errno = 0;
344 PyFPE_START_PROTECT("PyOS_string_to_double", return -1.0)
345 x = _PyOS_ascii_strtod(s, &fail_pos);
346 PyFPE_END_PROTECT(x)
347
348 if (errno == ENOMEM) {
349 PyErr_NoMemory();
350 fail_pos = (char *)s;
351 }
352 else if (!endptr && (fail_pos == s || *fail_pos != '\0'))
353 PyErr_Format(PyExc_ValueError,
354 "could not convert string to float: "
355 "%.200s", s);
356 else if (fail_pos == s)
357 PyErr_Format(PyExc_ValueError,
358 "could not convert string to float: "
359 "%.200s", s);
360 else if (errno == ERANGE && fabs(x) >= 1.0 && overflow_exception)
361 PyErr_Format(overflow_exception,
362 "value too large to convert to float: "
363 "%.200s", s);
364 else
365 result = x;
366
367 if (endptr != NULL)
368 *endptr = fail_pos;
369 return result;
370 }
371
372 /* Given a string that may have a decimal point in the current
373 locale, change it back to a dot. Since the string cannot get
374 longer, no need for a maximum buffer size parameter. */
375 Py_LOCAL_INLINE(void)
376 change_decimal_from_locale_to_dot(char* buffer)
377 {
378 struct lconv *locale_data = localeconv();
379 const char *decimal_point = locale_data->decimal_point;
380
381 if (decimal_point[0] != '.' || decimal_point[1] != 0) {
382 size_t decimal_point_len = strlen(decimal_point);
383
384 if (*buffer == '+' || *buffer == '-')
385 buffer++;
386 while (Py_ISDIGIT(*buffer))
387 buffer++;
388 if (strncmp(buffer, decimal_point, decimal_point_len) == 0) {
389 *buffer = '.';
390 buffer++;
391 if (decimal_point_len > 1) {
392 /* buffer needs to get smaller */
393 size_t rest_len = strlen(buffer +
394 (decimal_point_len - 1));
395 memmove(buffer,
396 buffer + (decimal_point_len - 1),
397 rest_len);
398 buffer[rest_len] = 0;
399 }
400 }
401 }
402 }
403
404
405 /* From the C99 standard, section 7.19.6:
406 The exponent always contains at least two digits, and only as many more digits
407 as necessary to represent the exponent.
408 */
409 #define MIN_EXPONENT_DIGITS 2
410
411 /* Ensure that any exponent, if present, is at least MIN_EXPONENT_DIGITS
412 in length. */
413 Py_LOCAL_INLINE(void)
414 ensure_minimum_exponent_length(char* buffer, size_t buf_size)
415 {
416 char *p = strpbrk(buffer, "eE");
417 if (p && (*(p + 1) == '-' || *(p + 1) == '+')) {
418 char *start = p + 2;
419 int exponent_digit_cnt = 0;
420 int leading_zero_cnt = 0;
421 int in_leading_zeros = 1;
422 int significant_digit_cnt;
423
424 /* Skip over the exponent and the sign. */
425 p += 2;
426
427 /* Find the end of the exponent, keeping track of leading
428 zeros. */
429 while (*p && Py_ISDIGIT(*p)) {
430 if (in_leading_zeros && *p == '0')
431 ++leading_zero_cnt;
432 if (*p != '0')
433 in_leading_zeros = 0;
434 ++p;
435 ++exponent_digit_cnt;
436 }
437
438 significant_digit_cnt = exponent_digit_cnt - leading_zero_cnt;
439 if (exponent_digit_cnt == MIN_EXPONENT_DIGITS) {
440 /* If there are 2 exactly digits, we're done,
441 regardless of what they contain */
442 }
443 else if (exponent_digit_cnt > MIN_EXPONENT_DIGITS) {
444 int extra_zeros_cnt;
445
446 /* There are more than 2 digits in the exponent. See
447 if we can delete some of the leading zeros */
448 if (significant_digit_cnt < MIN_EXPONENT_DIGITS)
449 significant_digit_cnt = MIN_EXPONENT_DIGITS;
450 extra_zeros_cnt = exponent_digit_cnt -
451 significant_digit_cnt;
452
453 /* Delete extra_zeros_cnt worth of characters from the
454 front of the exponent */
455 assert(extra_zeros_cnt >= 0);
456
457 /* Add one to significant_digit_cnt to copy the
458 trailing 0 byte, thus setting the length */
459 memmove(start,
460 start + extra_zeros_cnt,
461 significant_digit_cnt + 1);
462 }
463 else {
464 /* If there are fewer than 2 digits, add zeros
465 until there are 2, if there's enough room */
466 int zeros = MIN_EXPONENT_DIGITS - exponent_digit_cnt;
467 if (start + zeros + exponent_digit_cnt + 1
468 < buffer + buf_size) {
469 memmove(start + zeros, start,
470 exponent_digit_cnt + 1);
471 memset(start, '0', zeros);
472 }
473 }
474 }
475 }
476
477 /* Remove trailing zeros after the decimal point from a numeric string; also
478 remove the decimal point if all digits following it are zero. The numeric
479 string must end in '\0', and should not have any leading or trailing
480 whitespace. Assumes that the decimal point is '.'. */
481 Py_LOCAL_INLINE(void)
482 remove_trailing_zeros(char *buffer)
483 {
484 char *old_fraction_end, *new_fraction_end, *end, *p;
485
486 p = buffer;
487 if (*p == '-' || *p == '+')
488 /* Skip leading sign, if present */
489 ++p;
490 while (Py_ISDIGIT(*p))
491 ++p;
492
493 /* if there's no decimal point there's nothing to do */
494 if (*p++ != '.')
495 return;
496
497 /* scan any digits after the point */
498 while (Py_ISDIGIT(*p))
499 ++p;
500 old_fraction_end = p;
501
502 /* scan up to ending '\0' */
503 while (*p != '\0')
504 p++;
505 /* +1 to make sure that we move the null byte as well */
506 end = p+1;
507
508 /* scan back from fraction_end, looking for removable zeros */
509 p = old_fraction_end;
510 while (*(p-1) == '0')
511 --p;
512 /* and remove point if we've got that far */
513 if (*(p-1) == '.')
514 --p;
515 new_fraction_end = p;
516
517 memmove(new_fraction_end, old_fraction_end, end-old_fraction_end);
518 }
519
520 /* Ensure that buffer has a decimal point in it. The decimal point will not
521 be in the current locale, it will always be '.'. Don't add a decimal point
522 if an exponent is present. Also, convert to exponential notation where
523 adding a '.0' would produce too many significant digits (see issue 5864).
524
525 Returns a pointer to the fixed buffer, or NULL on failure.
526 */
527 Py_LOCAL_INLINE(char *)
528 ensure_decimal_point(char* buffer, size_t buf_size, int precision)
529 {
530 int digit_count, insert_count = 0, convert_to_exp = 0;
531 char *chars_to_insert, *digits_start;
532
533 /* search for the first non-digit character */
534 char *p = buffer;
535 if (*p == '-' || *p == '+')
536 /* Skip leading sign, if present. I think this could only
537 ever be '-', but it can't hurt to check for both. */
538 ++p;
539 digits_start = p;
540 while (*p && Py_ISDIGIT(*p))
541 ++p;
542 digit_count = Py_SAFE_DOWNCAST(p - digits_start, Py_ssize_t, int);
543
544 if (*p == '.') {
545 if (Py_ISDIGIT(*(p+1))) {
546 /* Nothing to do, we already have a decimal
547 point and a digit after it */
548 }
549 else {
550 /* We have a decimal point, but no following
551 digit. Insert a zero after the decimal. */
552 /* can't ever get here via PyOS_double_to_string */
553 assert(precision == -1);
554 ++p;
555 chars_to_insert = "0";
556 insert_count = 1;
557 }
558 }
559 else if (!(*p == 'e' || *p == 'E')) {
560 /* Don't add ".0" if we have an exponent. */
561 if (digit_count == precision) {
562 /* issue 5864: don't add a trailing .0 in the case
563 where the '%g'-formatted result already has as many
564 significant digits as were requested. Switch to
565 exponential notation instead. */
566 convert_to_exp = 1;
567 /* no exponent, no point, and we shouldn't land here
568 for infs and nans, so we must be at the end of the
569 string. */
570 assert(*p == '\0');
571 }
572 else {
573 assert(precision == -1 || digit_count < precision);
574 chars_to_insert = ".0";
575 insert_count = 2;
576 }
577 }
578 if (insert_count) {
579 size_t buf_len = strlen(buffer);
580 if (buf_len + insert_count + 1 >= buf_size) {
581 /* If there is not enough room in the buffer
582 for the additional text, just skip it. It's
583 not worth generating an error over. */
584 }
585 else {
586 memmove(p + insert_count, p,
587 buffer + strlen(buffer) - p + 1);
588 memcpy(p, chars_to_insert, insert_count);
589 }
590 }
591 if (convert_to_exp) {
592 int written;
593 size_t buf_avail;
594 p = digits_start;
595 /* insert decimal point */
596 assert(digit_count >= 1);
597 memmove(p+2, p+1, digit_count); /* safe, but overwrites nul */
598 p[1] = '.';
599 p += digit_count+1;
600 assert(p <= buf_size+buffer);
601 buf_avail = buf_size+buffer-p;
602 if (buf_avail == 0)
603 return NULL;
604 /* Add exponent. It's okay to use lower case 'e': we only
605 arrive here as a result of using the empty format code or
606 repr/str builtins and those never want an upper case 'E' */
607 written = PyOS_snprintf(p, buf_avail, "e%+.02d", digit_count-1);
608 if (!(0 <= written &&
609 written < Py_SAFE_DOWNCAST(buf_avail, size_t, int)))
610 /* output truncated, or something else bad happened */
611 return NULL;
612 remove_trailing_zeros(buffer);
613 }
614 return buffer;
615 }
616
617 /* see FORMATBUFLEN in unicodeobject.c */
618 #define FLOAT_FORMATBUFLEN 120
619
620 /**
621 * PyOS_ascii_formatd:
622 * @buffer: A buffer to place the resulting string in
623 * @buf_size: The length of the buffer.
624 * @format: The printf()-style format to use for the
625 * code to use for converting.
626 * @d: The #gdouble to convert
627 *
628 * Converts a #gdouble to a string, using the '.' as
629 * decimal point. To format the number you pass in
630 * a printf()-style format string. Allowed conversion
631 * specifiers are 'e', 'E', 'f', 'F', 'g', 'G', and 'Z'.
632 *
633 * 'Z' is the same as 'g', except it always has a decimal and
634 * at least one digit after the decimal.
635 *
636 * Return value: The pointer to the buffer with the converted string.
637 * On failure returns NULL but does not set any Python exception.
638 **/
639 char *
640 _PyOS_ascii_formatd(char *buffer,
641 size_t buf_size,
642 const char *format,
643 double d,
644 int precision)
645 {
646 char format_char;
647 size_t format_len = strlen(format);
648
649 /* Issue 2264: code 'Z' requires copying the format. 'Z' is 'g', but
650 also with at least one character past the decimal. */
651 char tmp_format[FLOAT_FORMATBUFLEN];
652
653 /* The last character in the format string must be the format char */
654 format_char = format[format_len - 1];
655
656 if (format[0] != '%')
657 return NULL;
658
659 /* I'm not sure why this test is here. It's ensuring that the format
660 string after the first character doesn't have a single quote, a
661 lowercase l, or a percent. This is the reverse of the commented-out
662 test about 10 lines ago. */
663 if (strpbrk(format + 1, "'l%"))
664 return NULL;
665
666 /* Also curious about this function is that it accepts format strings
667 like "%xg", which are invalid for floats. In general, the
668 interface to this function is not very good, but changing it is
669 difficult because it's a public API. */
670
671 if (!(format_char == 'e' || format_char == 'E' ||
672 format_char == 'f' || format_char == 'F' ||
673 format_char == 'g' || format_char == 'G' ||
674 format_char == 'Z'))
675 return NULL;
676
677 /* Map 'Z' format_char to 'g', by copying the format string and
678 replacing the final char with a 'g' */
679 if (format_char == 'Z') {
680 if (format_len + 1 >= sizeof(tmp_format)) {
681 /* The format won't fit in our copy. Error out. In
682 practice, this will never happen and will be
683 detected by returning NULL */
684 return NULL;
685 }
686 strcpy(tmp_format, format);
687 tmp_format[format_len - 1] = 'g';
688 format = tmp_format;
689 }
690
691
692 /* Have PyOS_snprintf do the hard work */
693 PyOS_snprintf(buffer, buf_size, format, d);
694
695 /* Do various fixups on the return string */
696
697 /* Get the current locale, and find the decimal point string.
698 Convert that string back to a dot. */
699 change_decimal_from_locale_to_dot(buffer);
700
701 /* If an exponent exists, ensure that the exponent is at least
702 MIN_EXPONENT_DIGITS digits, providing the buffer is large enough
703 for the extra zeros. Also, if there are more than
704 MIN_EXPONENT_DIGITS, remove as many zeros as possible until we get
705 back to MIN_EXPONENT_DIGITS */
706 ensure_minimum_exponent_length(buffer, buf_size);
707
708 /* If format_char is 'Z', make sure we have at least one character
709 after the decimal point (and make sure we have a decimal point);
710 also switch to exponential notation in some edge cases where the
711 extra character would produce more significant digits that we
712 really want. */
713 if (format_char == 'Z')
714 buffer = ensure_decimal_point(buffer, buf_size, precision);
715
716 return buffer;
717 }
718
719 char *
720 PyOS_ascii_formatd(char *buffer,
721 size_t buf_size,
722 const char *format,
723 double d)
724 {
725 if (PyErr_WarnEx(PyExc_DeprecationWarning,
726 "PyOS_ascii_formatd is deprecated, "
727 "use PyOS_double_to_string instead", 1) < 0)
728 return NULL;
729
730 return _PyOS_ascii_formatd(buffer, buf_size, format, d, -1);
731 }
732
733 #ifdef PY_NO_SHORT_FLOAT_REPR
734
735 /* The fallback code to use if _Py_dg_dtoa is not available. */
736
737 PyAPI_FUNC(char *) PyOS_double_to_string(double val,
738 char format_code,
739 int precision,
740 int flags,
741 int *type)
742 {
743 char format[32];
744 Py_ssize_t bufsize;
745 char *buf;
746 int t, exp;
747 int upper = 0;
748
749 /* Validate format_code, and map upper and lower case */
750 switch (format_code) {
751 case 'e': /* exponent */
752 case 'f': /* fixed */
753 case 'g': /* general */
754 break;
755 case 'E':
756 upper = 1;
757 format_code = 'e';
758 break;
759 case 'F':
760 upper = 1;
761 format_code = 'f';
762 break;
763 case 'G':
764 upper = 1;
765 format_code = 'g';
766 break;
767 case 'r': /* repr format */
768 /* Supplied precision is unused, must be 0. */
769 if (precision != 0) {
770 PyErr_BadInternalCall();
771 return NULL;
772 }
773 /* The repr() precision (17 significant decimal digits) is the
774 minimal number that is guaranteed to have enough precision
775 so that if the number is read back in the exact same binary
776 value is recreated. This is true for IEEE floating point
777 by design, and also happens to work for all other modern
778 hardware. */
779 precision = 17;
780 format_code = 'g';
781 break;
782 default:
783 PyErr_BadInternalCall();
784 return NULL;
785 }
786
787 /* Here's a quick-and-dirty calculation to figure out how big a buffer
788 we need. In general, for a finite float we need:
789
790 1 byte for each digit of the decimal significand, and
791
792 1 for a possible sign
793 1 for a possible decimal point
794 2 for a possible [eE][+-]
795 1 for each digit of the exponent; if we allow 19 digits
796 total then we're safe up to exponents of 2**63.
797 1 for the trailing nul byte
798
799 This gives a total of 24 + the number of digits in the significand,
800 and the number of digits in the significand is:
801
802 for 'g' format: at most precision, except possibly
803 when precision == 0, when it's 1.
804 for 'e' format: precision+1
805 for 'f' format: precision digits after the point, at least 1
806 before. To figure out how many digits appear before the point
807 we have to examine the size of the number. If fabs(val) < 1.0
808 then there will be only one digit before the point. If
809 fabs(val) >= 1.0, then there are at most
810
811 1+floor(log10(ceiling(fabs(val))))
812
813 digits before the point (where the 'ceiling' allows for the
814 possibility that the rounding rounds the integer part of val
815 up). A safe upper bound for the above quantity is
816 1+floor(exp/3), where exp is the unique integer such that 0.5
817 <= fabs(val)/2**exp < 1.0. This exp can be obtained from
818 frexp.
819
820 So we allow room for precision+1 digits for all formats, plus an
821 extra floor(exp/3) digits for 'f' format.
822
823 */
824
825 if (Py_IS_NAN(val) || Py_IS_INFINITY(val))
826 /* 3 for 'inf'/'nan', 1 for sign, 1 for '\0' */
827 bufsize = 5;
828 else {
829 bufsize = 25 + precision;
830 if (format_code == 'f' && fabs(val) >= 1.0) {
831 frexp(val, &exp);
832 bufsize += exp/3;
833 }
834 }
835
836 buf = PyMem_Malloc(bufsize);
837 if (buf == NULL) {
838 PyErr_NoMemory();
839 return NULL;
840 }
841
842 /* Handle nan and inf. */
843 if (Py_IS_NAN(val)) {
844 strcpy(buf, "nan");
845 t = Py_DTST_NAN;
846 } else if (Py_IS_INFINITY(val)) {
847 if (copysign(1., val) == 1.)
848 strcpy(buf, "inf");
849 else
850 strcpy(buf, "-inf");
851 t = Py_DTST_INFINITE;
852 } else {
853 t = Py_DTST_FINITE;
854 if (flags & Py_DTSF_ADD_DOT_0)
855 format_code = 'Z';
856
857 PyOS_snprintf(format, sizeof(format), "%%%s.%i%c",
858 (flags & Py_DTSF_ALT ? "#" : ""), precision,
859 format_code);
860 _PyOS_ascii_formatd(buf, bufsize, format, val, precision);
861 }
862
863 /* Add sign when requested. It's convenient (esp. when formatting
864 complex numbers) to include a sign even for inf and nan. */
865 if (flags & Py_DTSF_SIGN && buf[0] != '-') {
866 size_t len = strlen(buf);
867 /* the bufsize calculations above should ensure that we've got
868 space to add a sign */
869 assert((size_t)bufsize >= len+2);
870 memmove(buf+1, buf, len+1);
871 buf[0] = '+';
872 }
873 if (upper) {
874 /* Convert to upper case. */
875 char *p1;
876 for (p1 = buf; *p1; p1++)
877 *p1 = Py_TOUPPER(*p1);
878 }
879
880 if (type)
881 *type = t;
882 return buf;
883 }
884
885 #else
886
887 /* _Py_dg_dtoa is available. */
888
889 /* I'm using a lookup table here so that I don't have to invent a non-locale
890 specific way to convert to uppercase */
891 #define OFS_INF 0
892 #define OFS_NAN 1
893 #define OFS_E 2
894
895 /* The lengths of these are known to the code below, so don't change them */
896 static char *lc_float_strings[] = {
897 "inf",
898 "nan",
899 "e",
900 };
901 static char *uc_float_strings[] = {
902 "INF",
903 "NAN",
904 "E",
905 };
906
907
908 /* Convert a double d to a string, and return a PyMem_Malloc'd block of
909 memory contain the resulting string.
910
911 Arguments:
912 d is the double to be converted
913 format_code is one of 'e', 'f', 'g', 'r'. 'e', 'f' and 'g'
914 correspond to '%e', '%f' and '%g'; 'r' corresponds to repr.
915 mode is one of '0', '2' or '3', and is completely determined by
916 format_code: 'e' and 'g' use mode 2; 'f' mode 3, 'r' mode 0.
917 precision is the desired precision
918 always_add_sign is nonzero if a '+' sign should be included for positive
919 numbers
920 add_dot_0_if_integer is nonzero if integers in non-exponential form
921 should have ".0" added. Only applies to format codes 'r' and 'g'.
922 use_alt_formatting is nonzero if alternative formatting should be
923 used. Only applies to format codes 'e', 'f' and 'g'. For code 'g',
924 at most one of use_alt_formatting and add_dot_0_if_integer should
925 be nonzero.
926 type, if non-NULL, will be set to one of these constants to identify
927 the type of the 'd' argument:
928 Py_DTST_FINITE
929 Py_DTST_INFINITE
930 Py_DTST_NAN
931
932 Returns a PyMem_Malloc'd block of memory containing the resulting string,
933 or NULL on error. If NULL is returned, the Python error has been set.
934 */
935
936 static char *
937 format_float_short(double d, char format_code,
938 int mode, Py_ssize_t precision,
939 int always_add_sign, int add_dot_0_if_integer,
940 int use_alt_formatting, char **float_strings, int *type)
941 {
942 char *buf = NULL;
943 char *p = NULL;
944 Py_ssize_t bufsize = 0;
945 char *digits, *digits_end;
946 int decpt_as_int, sign, exp_len, exp = 0, use_exp = 0;
947 Py_ssize_t decpt, digits_len, vdigits_start, vdigits_end;
948 _Py_SET_53BIT_PRECISION_HEADER;
949
950 /* _Py_dg_dtoa returns a digit string (no decimal point or exponent).
951 Must be matched by a call to _Py_dg_freedtoa. */
952 _Py_SET_53BIT_PRECISION_START;
953 digits = _Py_dg_dtoa(d, mode, precision, &decpt_as_int, &sign,
954 &digits_end);
955 _Py_SET_53BIT_PRECISION_END;
956
957 decpt = (Py_ssize_t)decpt_as_int;
958 if (digits == NULL) {
959 /* The only failure mode is no memory. */
960 PyErr_NoMemory();
961 goto exit;
962 }
963 assert(digits_end != NULL && digits_end >= digits);
964 digits_len = digits_end - digits;
965
966 if (digits_len && !Py_ISDIGIT(digits[0])) {
967 /* Infinities and nans here; adapt Gay's output,
968 so convert Infinity to inf and NaN to nan, and
969 ignore sign of nan. Then return. */
970
971 /* ignore the actual sign of a nan */
972 if (digits[0] == 'n' || digits[0] == 'N')
973 sign = 0;
974
975 /* We only need 5 bytes to hold the result "+inf\0" . */
976 bufsize = 5; /* Used later in an assert. */
977 buf = (char *)PyMem_Malloc(bufsize);
978 if (buf == NULL) {
979 PyErr_NoMemory();
980 goto exit;
981 }
982 p = buf;
983
984 if (sign == 1) {
985 *p++ = '-';
986 }
987 else if (always_add_sign) {
988 *p++ = '+';
989 }
990 if (digits[0] == 'i' || digits[0] == 'I') {
991 strncpy(p, float_strings[OFS_INF], 3);
992 p += 3;
993
994 if (type)
995 *type = Py_DTST_INFINITE;
996 }
997 else if (digits[0] == 'n' || digits[0] == 'N') {
998 strncpy(p, float_strings[OFS_NAN], 3);
999 p += 3;
1000
1001 if (type)
1002 *type = Py_DTST_NAN;
1003 }
1004 else {
1005 /* shouldn't get here: Gay's code should always return
1006 something starting with a digit, an 'I', or 'N' */
1007 strncpy(p, "ERR", 3);
1008 p += 3;
(emitted by clang-analyzer)TODO: a detailed trace is available in the data model (not yet rendered in this report)
1009 assert(0);
1010 }
1011 goto exit;
1012 }
1013
1014 /* The result must be finite (not inf or nan). */
1015 if (type)
1016 *type = Py_DTST_FINITE;
1017
1018
1019 /* We got digits back, format them. We may need to pad 'digits'
1020 either on the left or right (or both) with extra zeros, so in
1021 general the resulting string has the form
1022
1023 [<sign>]<zeros><digits><zeros>[<exponent>]
1024
1025 where either of the <zeros> pieces could be empty, and there's a
1026 decimal point that could appear either in <digits> or in the
1027 leading or trailing <zeros>.
1028
1029 Imagine an infinite 'virtual' string vdigits, consisting of the
1030 string 'digits' (starting at index 0) padded on both the left and
1031 right with infinite strings of zeros. We want to output a slice
1032
1033 vdigits[vdigits_start : vdigits_end]
1034
1035 of this virtual string. Thus if vdigits_start < 0 then we'll end
1036 up producing some leading zeros; if vdigits_end > digits_len there
1037 will be trailing zeros in the output. The next section of code
1038 determines whether to use an exponent or not, figures out the
1039 position 'decpt' of the decimal point, and computes 'vdigits_start'
1040 and 'vdigits_end'. */
1041 vdigits_end = digits_len;
1042 switch (format_code) {
1043 case 'e':
1044 use_exp = 1;
1045 vdigits_end = precision;
1046 break;
1047 case 'f':
1048 vdigits_end = decpt + precision;
1049 break;
1050 case 'g':
1051 if (decpt <= -4 || decpt >
1052 (add_dot_0_if_integer ? precision-1 : precision))
1053 use_exp = 1;
1054 if (use_alt_formatting)
1055 vdigits_end = precision;
1056 break;
1057 case 'r':
1058 /* convert to exponential format at 1e16. We used to convert
1059 at 1e17, but that gives odd-looking results for some values
1060 when a 16-digit 'shortest' repr is padded with bogus zeros.
1061 For example, repr(2e16+8) would give 20000000000000010.0;
1062 the true value is 20000000000000008.0. */
1063 if (decpt <= -4 || decpt > 16)
1064 use_exp = 1;
1065 break;
1066 default:
1067 PyErr_BadInternalCall();
1068 goto exit;
1069 }
1070
1071 /* if using an exponent, reset decimal point position to 1 and adjust
1072 exponent accordingly.*/
1073 if (use_exp) {
1074 exp = decpt - 1;
1075 decpt = 1;
1076 }
1077 /* ensure vdigits_start < decpt <= vdigits_end, or vdigits_start <
1078 decpt < vdigits_end if add_dot_0_if_integer and no exponent */
1079 vdigits_start = decpt <= 0 ? decpt-1 : 0;
1080 if (!use_exp && add_dot_0_if_integer)
1081 vdigits_end = vdigits_end > decpt ? vdigits_end : decpt + 1;
1082 else
1083 vdigits_end = vdigits_end > decpt ? vdigits_end : decpt;
1084
1085 /* double check inequalities */
1086 assert(vdigits_start <= 0 &&
1087 0 <= digits_len &&
1088 digits_len <= vdigits_end);
1089 /* decimal point should be in (vdigits_start, vdigits_end] */
1090 assert(vdigits_start < decpt && decpt <= vdigits_end);
1091
1092 /* Compute an upper bound how much memory we need. This might be a few
1093 chars too long, but no big deal. */
1094 bufsize =
1095 /* sign, decimal point and trailing 0 byte */
1096 3 +
1097
1098 /* total digit count (including zero padding on both sides) */
1099 (vdigits_end - vdigits_start) +
1100
1101 /* exponent "e+100", max 3 numerical digits */
1102 (use_exp ? 5 : 0);
1103
1104 /* Now allocate the memory and initialize p to point to the start of
1105 it. */
1106 buf = (char *)PyMem_Malloc(bufsize);
1107 if (buf == NULL) {
1108 PyErr_NoMemory();
1109 goto exit;
1110 }
1111 p = buf;
1112
1113 /* Add a negative sign if negative, and a plus sign if non-negative
1114 and always_add_sign is true. */
1115 if (sign == 1)
1116 *p++ = '-';
1117 else if (always_add_sign)
1118 *p++ = '+';
1119
1120 /* note that exactly one of the three 'if' conditions is true,
1121 so we include exactly one decimal point */
1122 /* Zero padding on left of digit string */
1123 if (decpt <= 0) {
1124 memset(p, '0', decpt-vdigits_start);
1125 p += decpt - vdigits_start;
1126 *p++ = '.';
1127 memset(p, '0', 0-decpt);
1128 p += 0-decpt;
1129 }
1130 else {
1131 memset(p, '0', 0-vdigits_start);
1132 p += 0 - vdigits_start;
1133 }
1134
1135 /* Digits, with included decimal point */
1136 if (0 < decpt && decpt <= digits_len) {
1137 strncpy(p, digits, decpt-0);
1138 p += decpt-0;
1139 *p++ = '.';
1140 strncpy(p, digits+decpt, digits_len-decpt);
1141 p += digits_len-decpt;
1142 }
1143 else {
1144 strncpy(p, digits, digits_len);
1145 p += digits_len;
1146 }
1147
1148 /* And zeros on the right */
1149 if (digits_len < decpt) {
1150 memset(p, '0', decpt-digits_len);
1151 p += decpt-digits_len;
1152 *p++ = '.';
1153 memset(p, '0', vdigits_end-decpt);
1154 p += vdigits_end-decpt;
1155 }
1156 else {
1157 memset(p, '0', vdigits_end-digits_len);
1158 p += vdigits_end-digits_len;
1159 }
1160
1161 /* Delete a trailing decimal pt unless using alternative formatting. */
1162 if (p[-1] == '.' && !use_alt_formatting)
1163 p--;
1164
1165 /* Now that we've done zero padding, add an exponent if needed. */
1166 if (use_exp) {
1167 *p++ = float_strings[OFS_E][0];
1168 exp_len = sprintf(p, "%+.02d", exp);
1169 p += exp_len;
1170 }
1171 exit:
1172 if (buf) {
1173 *p = '\0';
(emitted by cppcheck) (emitted by cppcheck)1174 /* It's too late if this fails, as we've already stepped on
1175 memory that isn't ours. But it's an okay debugging test. */
1176 assert(p-buf < bufsize);
1177 }
1178 if (digits)
1179 _Py_dg_freedtoa(digits);
1180
1181 return buf;
1182 }
1183
1184
1185 PyAPI_FUNC(char *) PyOS_double_to_string(double val,
1186 char format_code,
1187 int precision,
1188 int flags,
1189 int *type)
1190 {
1191 char **float_strings = lc_float_strings;
1192 int mode;
1193
1194 /* Validate format_code, and map upper and lower case. Compute the
1195 mode and make any adjustments as needed. */
1196 switch (format_code) {
1197 /* exponent */
1198 case 'E':
1199 float_strings = uc_float_strings;
1200 format_code = 'e';
1201 /* Fall through. */
1202 case 'e':
1203 mode = 2;
1204 precision++;
1205 break;
1206
1207 /* fixed */
1208 case 'F':
1209 float_strings = uc_float_strings;
1210 format_code = 'f';
1211 /* Fall through. */
1212 case 'f':
1213 mode = 3;
1214 break;
1215
1216 /* general */
1217 case 'G':
1218 float_strings = uc_float_strings;
1219 format_code = 'g';
1220 /* Fall through. */
1221 case 'g':
1222 mode = 2;
1223 /* precision 0 makes no sense for 'g' format; interpret as 1 */
1224 if (precision == 0)
1225 precision = 1;
1226 break;
1227
1228 /* repr format */
1229 case 'r':
1230 mode = 0;
1231 /* Supplied precision is unused, must be 0. */
1232 if (precision != 0) {
1233 PyErr_BadInternalCall();
1234 return NULL;
1235 }
1236 break;
1237
1238 default:
1239 PyErr_BadInternalCall();
1240 return NULL;
1241 }
1242
1243 return format_float_short(val, format_code, mode, precision,
1244 flags & Py_DTSF_SIGN,
1245 flags & Py_DTSF_ADD_DOT_0,
1246 flags & Py_DTSF_ALT,
1247 float_strings, type);
1248 }
1249 #endif /* ifdef PY_NO_SHORT_FLOAT_REPR */