Python/pystrtod.c

   1 /* -*- Mode: C; c-file-style: "python" -*- */
   2
   3 #include <Python.h>
   4 #include <locale.h>
   5
   6 /**
   7  * PyOS_ascii_strtod:
   8  * @nptr:    the string to convert to a numeric value.
   9  * @endptr:  if non-%NULL, it returns the character after
  10  *           the last character used in the conversion.
  11  *
  12  * Converts a string to a #gdouble value.
  13  * This function behaves like the standard strtod() function
  14  * does in the C locale. It does this without actually
  15  * changing the current locale, since that would not be
  16  * thread-safe.
  17  *
  18  * This function is typically used when reading configuration
  19  * files or other non-user input that should be locale independent.
  20  * To handle input from the user you should normally use the
  21  * locale-sensitive system strtod() function.
  22  *
  23  * If the correct value would cause overflow, plus or minus %HUGE_VAL
  24  * is returned (according to the sign of the value), and %ERANGE is
  25  * stored in %errno. If the correct value would cause underflow,
  26  * zero is returned and %ERANGE is stored in %errno.
  27  * If memory allocation fails, %ENOMEM is stored in %errno.
  28  *
  29  * This function resets %errno before calling strtod() so that
  30  * you can reliably detect overflow and underflow.
  31  *
  32  * Return value: the #gdouble value.
  33  **/
  34
  35 /*
  36    Use system strtod;  since strtod is locale aware, we may
  37    have to first fix the decimal separator.
  38
  39    Note that unlike _Py_dg_strtod, the system strtod may not always give
  40    correctly rounded results.
  41 */
  42
  43 double
  44 PyOS_ascii_strtod(const char *nptr, char **endptr)
  45 {
  46         char *fail_pos;
  47         double val = -1.0;
  48         struct lconv *locale_data;
  49         const char *decimal_point;
  50         size_t decimal_point_len;
  51         const char *p, *decimal_point_pos;
  52         const char *end = NULL; /* Silence gcc */
  53         const char *digits_pos = NULL;
  54         int negate = 0;
  55
  56         assert(nptr != NULL);
  57
  58         fail_pos = NULL;
  59
  60         locale_data = localeconv();
  61         decimal_point = locale_data->decimal_point;
  62         decimal_point_len = strlen(decimal_point);
  63
  64         assert(decimal_point_len != 0);
  65
  66         decimal_point_pos = NULL;
  67
  68         /* Set errno to zero, so that we can distinguish zero results
  69            and underflows */
  70         errno = 0;
  71
  72         /* We process any leading whitespace and the optional sign manually,
  73            then pass the remainder to the system strtod.  This ensures that
  74            the result of an underflow has the correct sign. (bug #1725)  */
  75
  76         p = nptr;
  77         /* Skip leading space */
  78         while (Py_ISSPACE(*p))
  79                 p++;
  80
  81         /* Process leading sign, if present */
  82         if (*p == '-') {
  83                 negate = 1;
  84                 p++;
  85         }
  86         else if (*p == '+') {
  87                 p++;
  88         }
  89
  90         /* Parse infinities and nans */
  91         if (*p == 'i' || *p == 'I') {
  92                 if (PyOS_strnicmp(p, "inf", 3) == 0) {
  93                         val = Py_HUGE_VAL;
  94                         if (PyOS_strnicmp(p+3, "inity", 5) == 0)
  95                                 fail_pos = (char *)p+8;
  96                         else
  97                                 fail_pos = (char *)p+3;
  98                         goto got_val;
  99                 }
 100                 else
 101                         goto invalid_string;
 102         }
 103 #ifdef Py_NAN
 104         if (*p == 'n' || *p == 'N') {
 105                 if (PyOS_strnicmp(p, "nan", 3) == 0) {
 106                         val = Py_NAN;
 107                         fail_pos = (char *)p+3;
 108                         goto got_val;
 109                 }
 110                 else
 111                         goto invalid_string;
 112         }
 113 #endif
 114
 115         /* Some platform strtods accept hex floats; Python shouldn't (at the
 116            moment), so we check explicitly for strings starting with '0x'. */
 117         if (*p == '0' && (*(p+1) == 'x' || *(p+1) == 'X'))
 118                 goto invalid_string;
 119
 120         /* Check that what's left begins with a digit or decimal point */
 121         if (!Py_ISDIGIT(*p) && *p != '.')
 122                 goto invalid_string;
 123
 124         digits_pos = p;
 125         if (decimal_point[0] != '.' ||
 126             decimal_point[1] != 0)
 127         {
 128                 /* Look for a '.' in the input; if present, it'll need to be
 129                    swapped for the current locale's decimal point before we
 130                    call strtod.  On the other hand, if we find the current
 131                    locale's decimal point then the input is invalid. */
 132                 while (Py_ISDIGIT(*p))
 133                         p++;
 134
 135                 if (*p == '.')
 136                 {
 137                         decimal_point_pos = p++;
 138
 139                         /* locate end of number */
 140                         while (Py_ISDIGIT(*p))
 141                                 p++;
 142
 143                         if (*p == 'e' || *p == 'E')
 144                                 p++;
 145                         if (*p == '+' || *p == '-')
 146                                 p++;
 147                         while (Py_ISDIGIT(*p))
 148                                 p++;
 149                         end = p;
 150                 }
 151                 else if (strncmp(p, decimal_point, decimal_point_len) == 0)
 152                         /* Python bug #1417699 */
 153                         goto invalid_string;
 154                 /* For the other cases, we need not convert the decimal
 155                    point */
 156         }
 157
 158         if (decimal_point_pos) {
 159                 char *copy, *c;
 160                 /* Create a copy of the input, with the '.' converted to the
 161                    locale-specific decimal point */
 162                 copy = (char *)PyMem_MALLOC(end - digits_pos +
 163                                             1 + decimal_point_len);
 164                 if (copy == NULL) {
 165                         if (endptr)
 166                                 *endptr = (char *)nptr;
 167                         errno = ENOMEM;
 168                         return val;
 169                 }
 170
 171                 c = copy;
 172                 memcpy(c, digits_pos, decimal_point_pos - digits_pos);
 173                 c += decimal_point_pos - digits_pos;
 174                 memcpy(c, decimal_point, decimal_point_len);
 175                 c += decimal_point_len;
 176                 memcpy(c, decimal_point_pos + 1,
 177                        end - (decimal_point_pos + 1));
 178                 c += end - (decimal_point_pos + 1);
 179                 *c = 0;
 180
 181                 val = strtod(copy, &fail_pos);
 182
 183                 if (fail_pos)
 184                 {
 185                         if (fail_pos > decimal_point_pos)
 186                                 fail_pos = (char *)digits_pos +
 187                                         (fail_pos - copy) -
 188                                         (decimal_point_len - 1);
 189                         else
 190                                 fail_pos = (char *)digits_pos +
 191                                         (fail_pos - copy);
 192                 }
 193
 194                 PyMem_FREE(copy);
 195
 196         }
 197         else {
 198                 val = strtod(digits_pos, &fail_pos);
 199         }
 200
 201         if (fail_pos == digits_pos)
 202                 goto invalid_string;
 203
 204   got_val:
 205         if (negate && fail_pos != nptr)
 206                 val = -val;
 207
 208         if (endptr)
 209                 *endptr = fail_pos;
 210
 211         return val;
 212
 213   invalid_string:
 214         if (endptr)
 215                 *endptr = (char*)nptr;
 216         errno = EINVAL;
 217         return -1.0;
 218 }
 219
 220 double
 221 PyOS_ascii_atof(const char *nptr)
 222 {
 223         return PyOS_ascii_strtod(nptr, NULL);
 224 }
 225
 226
 227 /* Given a string that may have a decimal point in the current
 228    locale, change it back to a dot.  Since the string cannot get
 229    longer, no need for a maximum buffer size parameter. */
 230 Py_LOCAL_INLINE(void)
 231 change_decimal_from_locale_to_dot(char* buffer)
 232 {
 233         struct lconv *locale_data = localeconv();
 234         const char *decimal_point = locale_data->decimal_point;
 235
 236         if (decimal_point[0] != '.' || decimal_point[1] != 0) {
 237                 size_t decimal_point_len = strlen(decimal_point);
 238
 239                 if (*buffer == '+' || *buffer == '-')
 240                         buffer++;
 241                 while (Py_ISDIGIT(*buffer))
 242                         buffer++;
 243                 if (strncmp(buffer, decimal_point, decimal_point_len) == 0) {
 244                         *buffer = '.';
 245                         buffer++;
 246                         if (decimal_point_len > 1) {
 247                                 /* buffer needs to get smaller */
 248                                 size_t rest_len = strlen(buffer +
 249                                                      (decimal_point_len - 1));
 250                                 memmove(buffer,
 251                                         buffer + (decimal_point_len - 1),
 252                                         rest_len);
 253                                 buffer[rest_len] = 0;
 254                         }
 255                 }
 256         }
 257 }
 258
 259
 260 Py_LOCAL_INLINE(void)
 261 ensure_sign(char* buffer, size_t buf_size)
 262 {
 263         size_t len;
 264
 265         if (buffer[0] == '-')
 266                 /* Already have a sign. */
 267                 return;
 268
 269         /* Include the trailing 0 byte. */
 270         len = strlen(buffer)+1;
 271         if (len >= buf_size+1)
 272                 /* No room for the sign, don't do anything. */
 273                 return;
 274
 275         memmove(buffer+1, buffer, len);
 276         buffer[0] = '+';
 277 }
 278
 279 /* From the C99 standard, section 7.19.6:
 280 The exponent always contains at least two digits, and only as many more digits
 281 as necessary to represent the exponent.
 282 */
 283 #define MIN_EXPONENT_DIGITS 2
 284
 285 /* Ensure that any exponent, if present, is at least MIN_EXPONENT_DIGITS
 286    in length. */
 287 Py_LOCAL_INLINE(void)
 288 ensure_minimum_exponent_length(char* buffer, size_t buf_size)
 289 {
 290         char *p = strpbrk(buffer, "eE");
 291         if (p && (*(p + 1) == '-' || *(p + 1) == '+')) {
 292                 char *start = p + 2;
 293                 int exponent_digit_cnt = 0;
 294                 int leading_zero_cnt = 0;
 295                 int in_leading_zeros = 1;
 296                 int significant_digit_cnt;
 297
 298                 /* Skip over the exponent and the sign. */
 299                 p += 2;
 300
 301                 /* Find the end of the exponent, keeping track of leading
 302                    zeros. */
 303                 while (*p && Py_ISDIGIT(*p)) {
 304                         if (in_leading_zeros && *p == '0')
 305                                 ++leading_zero_cnt;
 306                         if (*p != '0')
 307                                 in_leading_zeros = 0;
 308                         ++p;
 309                         ++exponent_digit_cnt;
 310                 }
 311
 312                 significant_digit_cnt = exponent_digit_cnt - leading_zero_cnt;
 313                 if (exponent_digit_cnt == MIN_EXPONENT_DIGITS) {
 314                         /* If there are 2 exactly digits, we're done,
 315                            regardless of what they contain */
 316                 }
 317                 else if (exponent_digit_cnt > MIN_EXPONENT_DIGITS) {
 318                         int extra_zeros_cnt;
 319
 320                         /* There are more than 2 digits in the exponent.  See
 321                            if we can delete some of the leading zeros */
 322                         if (significant_digit_cnt < MIN_EXPONENT_DIGITS)
 323                                 significant_digit_cnt = MIN_EXPONENT_DIGITS;
 324                         extra_zeros_cnt = exponent_digit_cnt -
 325                                 significant_digit_cnt;
 326
 327                         /* Delete extra_zeros_cnt worth of characters from the
 328                            front of the exponent */
 329                         assert(extra_zeros_cnt >= 0);
 330
 331                         /* Add one to significant_digit_cnt to copy the
 332                            trailing 0 byte, thus setting the length */
 333                         memmove(start,
 334                                 start + extra_zeros_cnt,
 335                                 significant_digit_cnt + 1);
 336                 }
 337                 else {
 338                         /* If there are fewer than 2 digits, add zeros
 339                            until there are 2, if there's enough room */
 340                         int zeros = MIN_EXPONENT_DIGITS - exponent_digit_cnt;
 341                         if (start + zeros + exponent_digit_cnt + 1
 342                               < buffer + buf_size) {
 343                                 memmove(start + zeros, start,
 344                                         exponent_digit_cnt + 1);
 345                                 memset(start, '0', zeros);
 346                         }
 347                 }
 348         }
 349 }
 350
 351 /* Remove trailing zeros after the decimal point from a numeric string; also
 352    remove the decimal point if all digits following it are zero.  The numeric
 353    string must end in '\0', and should not have any leading or trailing
 354    whitespace.  Assumes that the decimal point is '.'. */
 355 Py_LOCAL_INLINE(void)
 356 remove_trailing_zeros(char *buffer)
 357 {
 358         char *old_fraction_end, *new_fraction_end, *end, *p;
 359
 360         p = buffer;
 361         if (*p == '-' || *p == '+')
 362                 /* Skip leading sign, if present */
 363                 ++p;
 364         while (Py_ISDIGIT(*p))
 365                 ++p;
 366
 367         /* if there's no decimal point there's nothing to do */
 368         if (*p++ != '.')
 369                 return;
 370
 371         /* scan any digits after the point */
 372         while (Py_ISDIGIT(*p))
 373                 ++p;
 374         old_fraction_end = p;
 375
 376         /* scan up to ending '\0' */
 377         while (*p != '\0')
 378                 p++;
 379         /* +1 to make sure that we move the null byte as well */
 380         end = p+1;
 381
 382         /* scan back from fraction_end, looking for removable zeros */
 383         p = old_fraction_end;
 384         while (*(p-1) == '0')
 385                 --p;
 386         /* and remove point if we've got that far */
 387         if (*(p-1) == '.')
 388                 --p;
 389         new_fraction_end = p;
 390
 391         memmove(new_fraction_end, old_fraction_end, end-old_fraction_end);
 392 }
 393
 394 /* Ensure that buffer has a decimal point in it.  The decimal point will not
 395    be in the current locale, it will always be '.'. Don't add a decimal point
 396    if an exponent is present.  Also, convert to exponential notation where
 397    adding a '.0' would produce too many significant digits (see issue 5864).
 398
 399    Returns a pointer to the fixed buffer, or NULL on failure.
 400 */
 401 Py_LOCAL_INLINE(char *)
 402 ensure_decimal_point(char* buffer, size_t buf_size, int precision)
 403 {
 404         int digit_count, insert_count = 0, convert_to_exp = 0;
 405         char* chars_to_insert, *digits_start;
 406
 407         /* search for the first non-digit character */
 408         char *p = buffer;
 409         if (*p == '-' || *p == '+')
 410                 /* Skip leading sign, if present.  I think this could only
 411                    ever be '-', but it can't hurt to check for both. */
 412                 ++p;
 413         digits_start = p;
 414         while (*p && Py_ISDIGIT(*p))
 415                 ++p;
 416         digit_count = Py_SAFE_DOWNCAST(p - digits_start, Py_ssize_t, int);
 417
 418         if (*p == '.') {
 419                 if (Py_ISDIGIT(*(p+1))) {
 420                         /* Nothing to do, we already have a decimal
 421                            point and a digit after it */
 422                 }
 423                 else {
 424                         /* We have a decimal point, but no following
 425                            digit.  Insert a zero after the decimal. */
 426                         /* can't ever get here via PyOS_double_to_string */
 427                         assert(precision == -1);
 428                         ++p;
 429                         chars_to_insert = "0";
 430                         insert_count = 1;
 431                 }
 432         }
 433         else if (!(*p == 'e' || *p == 'E')) {
 434                 /* Don't add ".0" if we have an exponent. */
 435                 if (digit_count == precision) {
 436                         /* issue 5864: don't add a trailing .0 in the case
 437                            where the '%g'-formatted result already has as many
 438                            significant digits as were requested.  Switch to
 439                            exponential notation instead. */
 440                         convert_to_exp = 1;
 441                         /* no exponent, no point, and we shouldn't land here
 442                            for infs and nans, so we must be at the end of the
 443                            string. */
 444                         assert(*p == '\0');
 445                 }
 446                 else {
 447                         assert(precision == -1 || digit_count < precision);
 448                         chars_to_insert = ".0";
 449                         insert_count = 2;
 450                 }
 451         }
 452         if (insert_count) {
 453                 size_t buf_len = strlen(buffer);
 454                 if (buf_len + insert_count + 1 >= buf_size) {
 455                         /* If there is not enough room in the buffer
 456                            for the additional text, just skip it.  It's
 457                            not worth generating an error over. */
 458                 }
 459                 else {
 460                         memmove(p + insert_count, p,
 461                                 buffer + strlen(buffer) - p + 1);
 462                         memcpy(p, chars_to_insert, insert_count);
 463                 }
 464         }
 465         if (convert_to_exp) {
 466                 int written;
 467                 size_t buf_avail;
 468                 p = digits_start;
 469                 /* insert decimal point */
 470                 assert(digit_count >= 1);
 471                 memmove(p+2, p+1, digit_count); /* safe, but overwrites nul */
 472                 p[1] = '.';
 473                 p += digit_count+1;
 474                 assert(p <= buf_size+buffer);
 475                 buf_avail = buf_size+buffer-p;
 476                 if (buf_avail == 0)
 477                         return NULL;
 478                 /* Add exponent.  It's okay to use lower case 'e': we only
 479                    arrive here as a result of using the empty format code or
 480                    repr/str builtins and those never want an upper case 'E' */
 481                 written = PyOS_snprintf(p, buf_avail, "e%+.02d", digit_count-1);
 482                 if (!(0 <= written &&
 483                       written < Py_SAFE_DOWNCAST(buf_avail, size_t, int)))
 484                         /* output truncated, or something else bad happened */
 485                         return NULL;
 486                 remove_trailing_zeros(buffer);
 487         }
 488         return buffer;
 489 }
 490
 491 /* see FORMATBUFLEN in unicodeobject.c */
 492 #define FLOAT_FORMATBUFLEN 120
 493
 494 /**
 495  * _PyOS_ascii_formatd:
 496  * @buffer: A buffer to place the resulting string in
 497  * @buf_size: The length of the buffer.
 498  * @format: The printf()-style format to use for the
 499  *          code to use for converting.
 500  * @d: The #gdouble to convert
 501  *
 502  * Converts a #gdouble to a string, using the '.' as
 503  * decimal point. To format the number you pass in
 504  * a printf()-style format string. Allowed conversion
 505  * specifiers are 'e', 'E', 'f', 'F', 'g', 'G', and 'Z'.
 506  *
 507  * 'Z' is the same as 'g', except it always has a decimal and
 508  *     at least one digit after the decimal.
 509  *
 510  * Return value: The pointer to the buffer with the converted string.
 511  * On failure returns NULL but does not set any Python exception.
 512  **/
 513 /* DEPRECATED, will be deleted in 2.8 and 3.2 */
 514 PyAPI_FUNC(char *)
 515 PyOS_ascii_formatd(char       *buffer,
 516                    size_t      buf_size,
 517                    const char *format,
 518                    double      d)
 519 {
 520         char format_char;
 521         size_t format_len = strlen(format);
 522
 523         /* Issue 2264: code 'Z' requires copying the format.  'Z' is 'g', but
 524            also with at least one character past the decimal. */
 525         char tmp_format[FLOAT_FORMATBUFLEN];
 526
 527         if (PyErr_WarnEx(PyExc_DeprecationWarning,
 528                          "PyOS_ascii_formatd is deprecated, "
 529                          "use PyOS_double_to_string instead", 1) < 0)
 530                 return NULL;
 531
 532         /* The last character in the format string must be the format char */
 533         format_char = format[format_len - 1];
 534
 535         if (format[0] != '%')
 536                 return NULL;
 537
 538         /* I'm not sure why this test is here.  It's ensuring that the format
 539            string after the first character doesn't have a single quote, a
 540            lowercase l, or a percent. This is the reverse of the commented-out
 541            test about 10 lines ago. */
 542         if (strpbrk(format + 1, "'l%"))
 543                 return NULL;
 544
 545         /* Also curious about this function is that it accepts format strings
 546            like "%xg", which are invalid for floats.  In general, the
 547            interface to this function is not very good, but changing it is
 548            difficult because it's a public API. */
 549
 550         if (!(format_char == 'e' || format_char == 'E' ||
 551               format_char == 'f' || format_char == 'F' ||
 552               format_char == 'g' || format_char == 'G' ||
 553               format_char == 'Z'))
 554                 return NULL;
 555
 556         /* Map 'Z' format_char to 'g', by copying the format string and
 557            replacing the final char with a 'g' */
 558         if (format_char == 'Z') {
 559                 if (format_len + 1 >= sizeof(tmp_format)) {
 560                         /* The format won't fit in our copy.  Error out.  In
 561                            practice, this will never happen and will be
 562                            detected by returning NULL */
 563                         return NULL;
 564                 }
 565                 strcpy(tmp_format, format);
 566                 tmp_format[format_len - 1] = 'g';
 567                 format = tmp_format;
 568         }
 569
 570
 571         /* Have PyOS_snprintf do the hard work */
 572         PyOS_snprintf(buffer, buf_size, format, d);
 573
 574         /* Do various fixups on the return string */
 575
 576         /* Get the current locale, and find the decimal point string.
 577            Convert that string back to a dot. */
 578         change_decimal_from_locale_to_dot(buffer);
 579
 580         /* If an exponent exists, ensure that the exponent is at least
 581            MIN_EXPONENT_DIGITS digits, providing the buffer is large enough
 582            for the extra zeros.  Also, if there are more than
 583            MIN_EXPONENT_DIGITS, remove as many zeros as possible until we get
 584            back to MIN_EXPONENT_DIGITS */
 585         ensure_minimum_exponent_length(buffer, buf_size);
 586
 587         /* If format_char is 'Z', make sure we have at least one character
 588            after the decimal point (and make sure we have a decimal point);
 589            also switch to exponential notation in some edge cases where the
 590            extra character would produce more significant digits that we
 591            really want. */
 592         if (format_char == 'Z')
 593                 buffer = ensure_decimal_point(buffer, buf_size, -1);
 594
 595         return buffer;
 596 }
 597
 598 PyAPI_FUNC(void)
 599 _PyOS_double_to_string(char *buf, size_t buf_len, double val,
 600                     char format_code, int precision,
 601                     int flags, int *ptype)
 602 {
 603         char format[32];
 604         int t;
 605         int upper = 0;
 606
 607         if (buf_len < 1) {
 608                 assert(0);
 609                 /* There's no way to signal this error. Just return. */
 610                 return;
 611         }
 612         buf[0] = 0;
 613
 614         /* Validate format_code, and map upper and lower case */
 615         switch (format_code) {
 616         case 'e':          /* exponent */
 617         case 'f':          /* fixed */
 618         case 'g':          /* general */
 619                 break;
 620         case 'E':
 621                 upper = 1;
 622                 format_code = 'e';
 623                 break;
 624         case 'F':
 625                 upper = 1;
 626                 format_code = 'f';
 627                 break;
 628         case 'G':
 629                 upper = 1;
 630                 format_code = 'g';
 631                 break;
 632         case 'r':          /* repr format */
 633                 /* Supplied precision is unused, must be 0. */
 634                 if (precision != 0)
 635                         return;
 636                 precision = 17;
 637                 format_code = 'g';
 638                 break;
 639         case 's':          /* str format */
 640                 /* Supplied precision is unused, must be 0. */
 641                 if (precision != 0)
 642                         return;
 643                 precision = 12;
 644                 format_code = 'g';
 645                 break;
 646         default:
 647                 assert(0);
 648                 return;
 649         }
 650
 651         /* Check for buf too small to fit "-inf". Other buffer too small
 652            conditions are dealt with when converting or formatting finite
 653            numbers. */
 654         if (buf_len < 5) {
 655                 assert(0);
 656                 return;
 657         }
 658
 659         /* Handle nan and inf. */
 660         if (Py_IS_NAN(val)) {
 661                 strcpy(buf, "nan");
 662                 t = Py_DTST_NAN;
 663         } else if (Py_IS_INFINITY(val)) {
 664                 if (copysign(1., val) == 1.)
 665                         strcpy(buf, "inf");
 666                 else
 667                         strcpy(buf, "-inf");
 668                 t = Py_DTST_INFINITE;
 669         } else {
 670                 t = Py_DTST_FINITE;
 671
 672                 /* Build the format string. */
 673                 PyOS_snprintf(format, sizeof(format), "%%%s.%i%c",
 674                               (flags & Py_DTSF_ALT ? "#" : ""), precision,
 675                               format_code);
 676
 677                 /* Have PyOS_snprintf do the hard work. */
 678                 PyOS_snprintf(buf, buf_len, format, val);
 679
 680                 /* Do various fixups on the return string */
 681
 682                 /* Get the current locale, and find the decimal point string.
 683                    Convert that string back to a dot. */
 684                 change_decimal_from_locale_to_dot(buf);
 685
 686                 /* If an exponent exists, ensure that the exponent is at least
 687                    MIN_EXPONENT_DIGITS digits, providing the buffer is large
 688                    enough for the extra zeros.  Also, if there are more than
 689                    MIN_EXPONENT_DIGITS, remove as many zeros as possible until
 690                    we get back to MIN_EXPONENT_DIGITS */
 691                 ensure_minimum_exponent_length(buf, buf_len);
 692
 693                 /* Possibly make sure we have at least one character after the
 694                    decimal point (and make sure we have a decimal point). */
 695                 if (flags & Py_DTSF_ADD_DOT_0)
 696                         buf = ensure_decimal_point(buf, buf_len, precision);
 697         }
 698
 699         /* Add the sign if asked and the result isn't negative. */
 700         if (flags & Py_DTSF_SIGN && buf[0] != '-')
 701                 ensure_sign(buf, buf_len);
 702
 703         if (upper) {
 704                 /* Convert to upper case. */
 705                 char *p;
 706                 for (p = buf; *p; p++)
 707                         *p = toupper(*p);
 708         }
 709
 710         if (ptype)
 711                 *ptype = t;
 712 }
 713
 714
 715 PyAPI_FUNC(char *) PyOS_double_to_string(double val,
 716                                          char format_code,
 717                                          int precision,
 718                                          int flags,
 719                                          int *ptype)
 720 {
 721         char buf[128];
 722         Py_ssize_t len;
 723         char *result;
 724
 725         _PyOS_double_to_string(buf, sizeof(buf), val, format_code, precision,
 726                                flags, ptype);
 727         len = strlen(buf);
 728         if (len == 0) {
 729                 PyErr_BadInternalCall();
 730                 return NULL;
 731         }
 732
 733         /* Add 1 for the trailing 0 byte. */
 734         result = PyMem_Malloc(len + 1);
 735         if (result == NULL) {
 736                 PyErr_NoMemory();
 737                 return NULL;
 738         }
 739         strcpy(result, buf);
 740
 741         return result;
 742 }