Recorded merge of revisions 81029 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r81029 | antoine.pitrou | 2010-05-09 16:46:46 +0200 (dim., 09 mai 2010) | 3 lines
Untabify C files. Will watch buildbots.
........
diff --git a/Python/pystrtod.c b/Python/pystrtod.c
index a1d7ff0..75e3032 100644
--- a/Python/pystrtod.c
+++ b/Python/pystrtod.c
@@ -9,11 +9,11 @@
static int
case_insensitive_match(const char *s, const char *t)
{
- while(*t && Py_TOLOWER(*s) == *t) {
- s++;
- t++;
- }
- return *t ? 0 : 1;
+ while(*t && Py_TOLOWER(*s) == *t) {
+ s++;
+ t++;
+ }
+ return *t ? 0 : 1;
}
/* _Py_parse_inf_or_nan: Attempt to parse a string of the form "nan", "inf" or
@@ -25,36 +25,36 @@
double
_Py_parse_inf_or_nan(const char *p, char **endptr)
{
- double retval;
- const char *s;
- int negate = 0;
+ double retval;
+ const char *s;
+ int negate = 0;
- s = p;
- if (*s == '-') {
- negate = 1;
- s++;
- }
- else if (*s == '+') {
- s++;
- }
- if (case_insensitive_match(s, "inf")) {
- s += 3;
- if (case_insensitive_match(s, "inity"))
- s += 5;
- retval = negate ? -Py_HUGE_VAL : Py_HUGE_VAL;
- }
+ s = p;
+ if (*s == '-') {
+ negate = 1;
+ s++;
+ }
+ else if (*s == '+') {
+ s++;
+ }
+ if (case_insensitive_match(s, "inf")) {
+ s += 3;
+ if (case_insensitive_match(s, "inity"))
+ s += 5;
+ retval = negate ? -Py_HUGE_VAL : Py_HUGE_VAL;
+ }
#ifdef Py_NAN
- else if (case_insensitive_match(s, "nan")) {
- s += 3;
- retval = negate ? -Py_NAN : Py_NAN;
- }
+ else if (case_insensitive_match(s, "nan")) {
+ s += 3;
+ retval = negate ? -Py_NAN : Py_NAN;
+ }
#endif
- else {
- s = p;
- retval = -1.0;
- }
- *endptr = (char *)s;
- return retval;
+ else {
+ s = p;
+ retval = -1.0;
+ }
+ *endptr = (char *)s;
+ return retval;
}
/**
@@ -62,7 +62,7 @@
* @nptr: the string to convert to a numeric value.
* @endptr: if non-%NULL, it returns the character after
* the last character used in the conversion.
- *
+ *
* Converts a string to a #gdouble value.
* This function behaves like the standard strtod() function
* does in the C locale. It does this without actually
@@ -79,7 +79,7 @@
* stored in %errno. If the correct value would cause underflow,
* zero is returned and %ERANGE is stored in %errno.
* If memory allocation fails, %ENOMEM is stored in %errno.
- *
+ *
* This function resets %errno before calling strtod() so that
* you can reliably detect overflow and underflow.
*
@@ -91,23 +91,23 @@
static double
_PyOS_ascii_strtod(const char *nptr, char **endptr)
{
- double result;
- _Py_SET_53BIT_PRECISION_HEADER;
+ double result;
+ _Py_SET_53BIT_PRECISION_HEADER;
- assert(nptr != NULL);
- /* Set errno to zero, so that we can distinguish zero results
- and underflows */
- errno = 0;
+ assert(nptr != NULL);
+ /* Set errno to zero, so that we can distinguish zero results
+ and underflows */
+ errno = 0;
- _Py_SET_53BIT_PRECISION_START;
- result = _Py_dg_strtod(nptr, endptr);
- _Py_SET_53BIT_PRECISION_END;
+ _Py_SET_53BIT_PRECISION_START;
+ result = _Py_dg_strtod(nptr, endptr);
+ _Py_SET_53BIT_PRECISION_END;
- if (*endptr == nptr)
- /* string might represent an inf or nan */
- result = _Py_parse_inf_or_nan(nptr, endptr);
+ if (*endptr == nptr)
+ /* string might represent an inf or nan */
+ result = _Py_parse_inf_or_nan(nptr, endptr);
- return result;
+ return result;
}
@@ -124,148 +124,148 @@
static double
_PyOS_ascii_strtod(const char *nptr, char **endptr)
{
- char *fail_pos;
- double val = -1.0;
- struct lconv *locale_data;
- const char *decimal_point;
- size_t decimal_point_len;
- const char *p, *decimal_point_pos;
- const char *end = NULL; /* Silence gcc */
- const char *digits_pos = NULL;
- int negate = 0;
+ char *fail_pos;
+ double val = -1.0;
+ struct lconv *locale_data;
+ const char *decimal_point;
+ size_t decimal_point_len;
+ const char *p, *decimal_point_pos;
+ const char *end = NULL; /* Silence gcc */
+ const char *digits_pos = NULL;
+ int negate = 0;
- assert(nptr != NULL);
+ assert(nptr != NULL);
- fail_pos = NULL;
+ fail_pos = NULL;
- locale_data = localeconv();
- decimal_point = locale_data->decimal_point;
- decimal_point_len = strlen(decimal_point);
+ locale_data = localeconv();
+ decimal_point = locale_data->decimal_point;
+ decimal_point_len = strlen(decimal_point);
- assert(decimal_point_len != 0);
+ assert(decimal_point_len != 0);
- decimal_point_pos = NULL;
+ decimal_point_pos = NULL;
- /* Parse infinities and nans */
- val = _Py_parse_inf_or_nan(nptr, endptr);
- if (*endptr != nptr)
- return val;
+ /* Parse infinities and nans */
+ val = _Py_parse_inf_or_nan(nptr, endptr);
+ if (*endptr != nptr)
+ return val;
- /* Set errno to zero, so that we can distinguish zero results
- and underflows */
- errno = 0;
+ /* Set errno to zero, so that we can distinguish zero results
+ and underflows */
+ errno = 0;
- /* We process the optional sign manually, then pass the remainder to
- the system strtod. This ensures that the result of an underflow
- has the correct sign. (bug #1725) */
- p = nptr;
- /* Process leading sign, if present */
- if (*p == '-') {
- negate = 1;
- p++;
- }
- else if (*p == '+') {
- p++;
- }
+ /* We process the optional sign manually, then pass the remainder to
+ the system strtod. This ensures that the result of an underflow
+ has the correct sign. (bug #1725) */
+ p = nptr;
+ /* Process leading sign, if present */
+ if (*p == '-') {
+ negate = 1;
+ p++;
+ }
+ else if (*p == '+') {
+ p++;
+ }
- /* Some platform strtods accept hex floats; Python shouldn't (at the
- moment), so we check explicitly for strings starting with '0x'. */
- if (*p == '0' && (*(p+1) == 'x' || *(p+1) == 'X'))
- goto invalid_string;
+ /* Some platform strtods accept hex floats; Python shouldn't (at the
+ moment), so we check explicitly for strings starting with '0x'. */
+ if (*p == '0' && (*(p+1) == 'x' || *(p+1) == 'X'))
+ goto invalid_string;
- /* Check that what's left begins with a digit or decimal point */
- if (!Py_ISDIGIT(*p) && *p != '.')
- goto invalid_string;
+ /* Check that what's left begins with a digit or decimal point */
+ if (!Py_ISDIGIT(*p) && *p != '.')
+ goto invalid_string;
- digits_pos = p;
- if (decimal_point[0] != '.' ||
- decimal_point[1] != 0)
- {
- /* Look for a '.' in the input; if present, it'll need to be
- swapped for the current locale's decimal point before we
- call strtod. On the other hand, if we find the current
- locale's decimal point then the input is invalid. */
- while (Py_ISDIGIT(*p))
- p++;
+ digits_pos = p;
+ if (decimal_point[0] != '.' ||
+ decimal_point[1] != 0)
+ {
+ /* Look for a '.' in the input; if present, it'll need to be
+ swapped for the current locale's decimal point before we
+ call strtod. On the other hand, if we find the current
+ locale's decimal point then the input is invalid. */
+ while (Py_ISDIGIT(*p))
+ p++;
- if (*p == '.')
- {
- decimal_point_pos = p++;
+ if (*p == '.')
+ {
+ decimal_point_pos = p++;
- /* locate end of number */
- while (Py_ISDIGIT(*p))
- p++;
+ /* locate end of number */
+ while (Py_ISDIGIT(*p))
+ p++;
- if (*p == 'e' || *p == 'E')
- p++;
- if (*p == '+' || *p == '-')
- p++;
- while (Py_ISDIGIT(*p))
- p++;
- end = p;
- }
- else if (strncmp(p, decimal_point, decimal_point_len) == 0)
- /* Python bug #1417699 */
- goto invalid_string;
- /* For the other cases, we need not convert the decimal
- point */
- }
+ if (*p == 'e' || *p == 'E')
+ p++;
+ if (*p == '+' || *p == '-')
+ p++;
+ while (Py_ISDIGIT(*p))
+ p++;
+ end = p;
+ }
+ else if (strncmp(p, decimal_point, decimal_point_len) == 0)
+ /* Python bug #1417699 */
+ goto invalid_string;
+ /* For the other cases, we need not convert the decimal
+ point */
+ }
- if (decimal_point_pos) {
- char *copy, *c;
- /* Create a copy of the input, with the '.' converted to the
- locale-specific decimal point */
- copy = (char *)PyMem_MALLOC(end - digits_pos +
- 1 + decimal_point_len);
- if (copy == NULL) {
- *endptr = (char *)nptr;
- errno = ENOMEM;
- return val;
- }
+ if (decimal_point_pos) {
+ char *copy, *c;
+ /* Create a copy of the input, with the '.' converted to the
+ locale-specific decimal point */
+ copy = (char *)PyMem_MALLOC(end - digits_pos +
+ 1 + decimal_point_len);
+ if (copy == NULL) {
+ *endptr = (char *)nptr;
+ errno = ENOMEM;
+ return val;
+ }
- c = copy;
- memcpy(c, digits_pos, decimal_point_pos - digits_pos);
- c += decimal_point_pos - digits_pos;
- memcpy(c, decimal_point, decimal_point_len);
- c += decimal_point_len;
- memcpy(c, decimal_point_pos + 1,
- end - (decimal_point_pos + 1));
- c += end - (decimal_point_pos + 1);
- *c = 0;
+ c = copy;
+ memcpy(c, digits_pos, decimal_point_pos - digits_pos);
+ c += decimal_point_pos - digits_pos;
+ memcpy(c, decimal_point, decimal_point_len);
+ c += decimal_point_len;
+ memcpy(c, decimal_point_pos + 1,
+ end - (decimal_point_pos + 1));
+ c += end - (decimal_point_pos + 1);
+ *c = 0;
- val = strtod(copy, &fail_pos);
+ val = strtod(copy, &fail_pos);
- if (fail_pos)
- {
- if (fail_pos > decimal_point_pos)
- fail_pos = (char *)digits_pos +
- (fail_pos - copy) -
- (decimal_point_len - 1);
- else
- fail_pos = (char *)digits_pos +
- (fail_pos - copy);
- }
+ if (fail_pos)
+ {
+ if (fail_pos > decimal_point_pos)
+ fail_pos = (char *)digits_pos +
+ (fail_pos - copy) -
+ (decimal_point_len - 1);
+ else
+ fail_pos = (char *)digits_pos +
+ (fail_pos - copy);
+ }
- PyMem_FREE(copy);
+ PyMem_FREE(copy);
- }
- else {
- val = strtod(digits_pos, &fail_pos);
- }
+ }
+ else {
+ val = strtod(digits_pos, &fail_pos);
+ }
- if (fail_pos == digits_pos)
- goto invalid_string;
+ if (fail_pos == digits_pos)
+ goto invalid_string;
- if (negate && fail_pos != nptr)
- val = -val;
- *endptr = fail_pos;
+ if (negate && fail_pos != nptr)
+ val = -val;
+ *endptr = fail_pos;
- return val;
+ return val;
invalid_string:
- *endptr = (char*)nptr;
- errno = EINVAL;
- return -1.0;
+ *endptr = (char*)nptr;
+ errno = EINVAL;
+ return -1.0;
}
#endif
@@ -296,39 +296,39 @@
double
PyOS_string_to_double(const char *s,
- char **endptr,
- PyObject *overflow_exception)
+ char **endptr,
+ PyObject *overflow_exception)
{
- double x, result=-1.0;
- char *fail_pos;
+ double x, result=-1.0;
+ char *fail_pos;
- errno = 0;
- PyFPE_START_PROTECT("PyOS_string_to_double", return -1.0)
- x = _PyOS_ascii_strtod(s, &fail_pos);
- PyFPE_END_PROTECT(x)
+ errno = 0;
+ PyFPE_START_PROTECT("PyOS_string_to_double", return -1.0)
+ x = _PyOS_ascii_strtod(s, &fail_pos);
+ PyFPE_END_PROTECT(x)
- if (errno == ENOMEM) {
- PyErr_NoMemory();
- fail_pos = (char *)s;
- }
- else if (!endptr && (fail_pos == s || *fail_pos != '\0'))
- PyErr_Format(PyExc_ValueError,
- "could not convert string to float: "
- "%.200s", s);
- else if (fail_pos == s)
- PyErr_Format(PyExc_ValueError,
- "could not convert string to float: "
- "%.200s", s);
- else if (errno == ERANGE && fabs(x) >= 1.0 && overflow_exception)
- PyErr_Format(overflow_exception,
- "value too large to convert to float: "
- "%.200s", s);
- else
- result = x;
+ if (errno == ENOMEM) {
+ PyErr_NoMemory();
+ fail_pos = (char *)s;
+ }
+ else if (!endptr && (fail_pos == s || *fail_pos != '\0'))
+ PyErr_Format(PyExc_ValueError,
+ "could not convert string to float: "
+ "%.200s", s);
+ else if (fail_pos == s)
+ PyErr_Format(PyExc_ValueError,
+ "could not convert string to float: "
+ "%.200s", s);
+ else if (errno == ERANGE && fabs(x) >= 1.0 && overflow_exception)
+ PyErr_Format(overflow_exception,
+ "value too large to convert to float: "
+ "%.200s", s);
+ else
+ result = x;
- if (endptr != NULL)
- *endptr = fail_pos;
- return result;
+ if (endptr != NULL)
+ *endptr = fail_pos;
+ return result;
}
#ifdef PY_NO_SHORT_FLOAT_REPR
@@ -339,30 +339,30 @@
Py_LOCAL_INLINE(void)
change_decimal_from_locale_to_dot(char* buffer)
{
- struct lconv *locale_data = localeconv();
- const char *decimal_point = locale_data->decimal_point;
+ struct lconv *locale_data = localeconv();
+ const char *decimal_point = locale_data->decimal_point;
- if (decimal_point[0] != '.' || decimal_point[1] != 0) {
- size_t decimal_point_len = strlen(decimal_point);
+ if (decimal_point[0] != '.' || decimal_point[1] != 0) {
+ size_t decimal_point_len = strlen(decimal_point);
- if (*buffer == '+' || *buffer == '-')
- buffer++;
- while (Py_ISDIGIT(*buffer))
- buffer++;
- if (strncmp(buffer, decimal_point, decimal_point_len) == 0) {
- *buffer = '.';
- buffer++;
- if (decimal_point_len > 1) {
- /* buffer needs to get smaller */
- size_t rest_len = strlen(buffer +
- (decimal_point_len - 1));
- memmove(buffer,
- buffer + (decimal_point_len - 1),
- rest_len);
- buffer[rest_len] = 0;
- }
- }
- }
+ if (*buffer == '+' || *buffer == '-')
+ buffer++;
+ while (Py_ISDIGIT(*buffer))
+ buffer++;
+ if (strncmp(buffer, decimal_point, decimal_point_len) == 0) {
+ *buffer = '.';
+ buffer++;
+ if (decimal_point_len > 1) {
+ /* buffer needs to get smaller */
+ size_t rest_len = strlen(buffer +
+ (decimal_point_len - 1));
+ memmove(buffer,
+ buffer + (decimal_point_len - 1),
+ rest_len);
+ buffer[rest_len] = 0;
+ }
+ }
+ }
}
@@ -377,65 +377,65 @@
Py_LOCAL_INLINE(void)
ensure_minimum_exponent_length(char* buffer, size_t buf_size)
{
- char *p = strpbrk(buffer, "eE");
- if (p && (*(p + 1) == '-' || *(p + 1) == '+')) {
- char *start = p + 2;
- int exponent_digit_cnt = 0;
- int leading_zero_cnt = 0;
- int in_leading_zeros = 1;
- int significant_digit_cnt;
+ char *p = strpbrk(buffer, "eE");
+ if (p && (*(p + 1) == '-' || *(p + 1) == '+')) {
+ char *start = p + 2;
+ int exponent_digit_cnt = 0;
+ int leading_zero_cnt = 0;
+ int in_leading_zeros = 1;
+ int significant_digit_cnt;
- /* Skip over the exponent and the sign. */
- p += 2;
+ /* Skip over the exponent and the sign. */
+ p += 2;
- /* Find the end of the exponent, keeping track of leading
- zeros. */
- while (*p && Py_ISDIGIT(*p)) {
- if (in_leading_zeros && *p == '0')
- ++leading_zero_cnt;
- if (*p != '0')
- in_leading_zeros = 0;
- ++p;
- ++exponent_digit_cnt;
- }
+ /* Find the end of the exponent, keeping track of leading
+ zeros. */
+ while (*p && Py_ISDIGIT(*p)) {
+ if (in_leading_zeros && *p == '0')
+ ++leading_zero_cnt;
+ if (*p != '0')
+ in_leading_zeros = 0;
+ ++p;
+ ++exponent_digit_cnt;
+ }
- significant_digit_cnt = exponent_digit_cnt - leading_zero_cnt;
- if (exponent_digit_cnt == MIN_EXPONENT_DIGITS) {
- /* If there are 2 exactly digits, we're done,
- regardless of what they contain */
- }
- else if (exponent_digit_cnt > MIN_EXPONENT_DIGITS) {
- int extra_zeros_cnt;
+ significant_digit_cnt = exponent_digit_cnt - leading_zero_cnt;
+ if (exponent_digit_cnt == MIN_EXPONENT_DIGITS) {
+ /* If there are 2 exactly digits, we're done,
+ regardless of what they contain */
+ }
+ else if (exponent_digit_cnt > MIN_EXPONENT_DIGITS) {
+ int extra_zeros_cnt;
- /* There are more than 2 digits in the exponent. See
- if we can delete some of the leading zeros */
- if (significant_digit_cnt < MIN_EXPONENT_DIGITS)
- significant_digit_cnt = MIN_EXPONENT_DIGITS;
- extra_zeros_cnt = exponent_digit_cnt -
- significant_digit_cnt;
+ /* There are more than 2 digits in the exponent. See
+ if we can delete some of the leading zeros */
+ if (significant_digit_cnt < MIN_EXPONENT_DIGITS)
+ significant_digit_cnt = MIN_EXPONENT_DIGITS;
+ extra_zeros_cnt = exponent_digit_cnt -
+ significant_digit_cnt;
- /* Delete extra_zeros_cnt worth of characters from the
- front of the exponent */
- assert(extra_zeros_cnt >= 0);
+ /* Delete extra_zeros_cnt worth of characters from the
+ front of the exponent */
+ assert(extra_zeros_cnt >= 0);
- /* Add one to significant_digit_cnt to copy the
- trailing 0 byte, thus setting the length */
- memmove(start,
- start + extra_zeros_cnt,
- significant_digit_cnt + 1);
- }
- else {
- /* If there are fewer than 2 digits, add zeros
- until there are 2, if there's enough room */
- int zeros = MIN_EXPONENT_DIGITS - exponent_digit_cnt;
- if (start + zeros + exponent_digit_cnt + 1
- < buffer + buf_size) {
- memmove(start + zeros, start,
- exponent_digit_cnt + 1);
- memset(start, '0', zeros);
- }
- }
- }
+ /* Add one to significant_digit_cnt to copy the
+ trailing 0 byte, thus setting the length */
+ memmove(start,
+ start + extra_zeros_cnt,
+ significant_digit_cnt + 1);
+ }
+ else {
+ /* If there are fewer than 2 digits, add zeros
+ until there are 2, if there's enough room */
+ int zeros = MIN_EXPONENT_DIGITS - exponent_digit_cnt;
+ if (start + zeros + exponent_digit_cnt + 1
+ < buffer + buf_size) {
+ memmove(start + zeros, start,
+ exponent_digit_cnt + 1);
+ memset(start, '0', zeros);
+ }
+ }
+ }
}
/* Remove trailing zeros after the decimal point from a numeric string; also
@@ -445,40 +445,40 @@
Py_LOCAL_INLINE(void)
remove_trailing_zeros(char *buffer)
{
- char *old_fraction_end, *new_fraction_end, *end, *p;
+ char *old_fraction_end, *new_fraction_end, *end, *p;
- p = buffer;
- if (*p == '-' || *p == '+')
- /* Skip leading sign, if present */
- ++p;
- while (Py_ISDIGIT(*p))
- ++p;
+ p = buffer;
+ if (*p == '-' || *p == '+')
+ /* Skip leading sign, if present */
+ ++p;
+ while (Py_ISDIGIT(*p))
+ ++p;
- /* if there's no decimal point there's nothing to do */
- if (*p++ != '.')
- return;
+ /* if there's no decimal point there's nothing to do */
+ if (*p++ != '.')
+ return;
- /* scan any digits after the point */
- while (Py_ISDIGIT(*p))
- ++p;
- old_fraction_end = p;
+ /* scan any digits after the point */
+ while (Py_ISDIGIT(*p))
+ ++p;
+ old_fraction_end = p;
- /* scan up to ending '\0' */
- while (*p != '\0')
- p++;
- /* +1 to make sure that we move the null byte as well */
- end = p+1;
+ /* scan up to ending '\0' */
+ while (*p != '\0')
+ p++;
+ /* +1 to make sure that we move the null byte as well */
+ end = p+1;
- /* scan back from fraction_end, looking for removable zeros */
- p = old_fraction_end;
- while (*(p-1) == '0')
- --p;
- /* and remove point if we've got that far */
- if (*(p-1) == '.')
- --p;
- new_fraction_end = p;
+ /* scan back from fraction_end, looking for removable zeros */
+ p = old_fraction_end;
+ while (*(p-1) == '0')
+ --p;
+ /* and remove point if we've got that far */
+ if (*(p-1) == '.')
+ --p;
+ new_fraction_end = p;
- memmove(new_fraction_end, old_fraction_end, end-old_fraction_end);
+ memmove(new_fraction_end, old_fraction_end, end-old_fraction_end);
}
/* Ensure that buffer has a decimal point in it. The decimal point will not
@@ -491,91 +491,91 @@
Py_LOCAL_INLINE(char *)
ensure_decimal_point(char* buffer, size_t buf_size, int precision)
{
- int digit_count, insert_count = 0, convert_to_exp = 0;
- char *chars_to_insert, *digits_start;
+ int digit_count, insert_count = 0, convert_to_exp = 0;
+ char *chars_to_insert, *digits_start;
- /* search for the first non-digit character */
- char *p = buffer;
- if (*p == '-' || *p == '+')
- /* Skip leading sign, if present. I think this could only
- ever be '-', but it can't hurt to check for both. */
- ++p;
- digits_start = p;
- while (*p && Py_ISDIGIT(*p))
- ++p;
- digit_count = Py_SAFE_DOWNCAST(p - digits_start, Py_ssize_t, int);
+ /* search for the first non-digit character */
+ char *p = buffer;
+ if (*p == '-' || *p == '+')
+ /* Skip leading sign, if present. I think this could only
+ ever be '-', but it can't hurt to check for both. */
+ ++p;
+ digits_start = p;
+ while (*p && Py_ISDIGIT(*p))
+ ++p;
+ digit_count = Py_SAFE_DOWNCAST(p - digits_start, Py_ssize_t, int);
- if (*p == '.') {
- if (Py_ISDIGIT(*(p+1))) {
- /* Nothing to do, we already have a decimal
- point and a digit after it */
- }
- else {
- /* We have a decimal point, but no following
- digit. Insert a zero after the decimal. */
- /* can't ever get here via PyOS_double_to_string */
- assert(precision == -1);
- ++p;
- chars_to_insert = "0";
- insert_count = 1;
- }
- }
- else if (!(*p == 'e' || *p == 'E')) {
- /* Don't add ".0" if we have an exponent. */
- if (digit_count == precision) {
- /* issue 5864: don't add a trailing .0 in the case
- where the '%g'-formatted result already has as many
- significant digits as were requested. Switch to
- exponential notation instead. */
- convert_to_exp = 1;
- /* no exponent, no point, and we shouldn't land here
- for infs and nans, so we must be at the end of the
- string. */
- assert(*p == '\0');
- }
- else {
- assert(precision == -1 || digit_count < precision);
- chars_to_insert = ".0";
- insert_count = 2;
- }
- }
- if (insert_count) {
- size_t buf_len = strlen(buffer);
- if (buf_len + insert_count + 1 >= buf_size) {
- /* If there is not enough room in the buffer
- for the additional text, just skip it. It's
- not worth generating an error over. */
- }
- else {
- memmove(p + insert_count, p,
- buffer + strlen(buffer) - p + 1);
- memcpy(p, chars_to_insert, insert_count);
- }
- }
- if (convert_to_exp) {
- int written;
- size_t buf_avail;
- p = digits_start;
- /* insert decimal point */
- assert(digit_count >= 1);
- memmove(p+2, p+1, digit_count); /* safe, but overwrites nul */
- p[1] = '.';
- p += digit_count+1;
- assert(p <= buf_size+buffer);
- buf_avail = buf_size+buffer-p;
- if (buf_avail == 0)
- return NULL;
- /* Add exponent. It's okay to use lower case 'e': we only
- arrive here as a result of using the empty format code or
- repr/str builtins and those never want an upper case 'E' */
- written = PyOS_snprintf(p, buf_avail, "e%+.02d", digit_count-1);
- if (!(0 <= written &&
- written < Py_SAFE_DOWNCAST(buf_avail, size_t, int)))
- /* output truncated, or something else bad happened */
- return NULL;
- remove_trailing_zeros(buffer);
- }
- return buffer;
+ if (*p == '.') {
+ if (Py_ISDIGIT(*(p+1))) {
+ /* Nothing to do, we already have a decimal
+ point and a digit after it */
+ }
+ else {
+ /* We have a decimal point, but no following
+ digit. Insert a zero after the decimal. */
+ /* can't ever get here via PyOS_double_to_string */
+ assert(precision == -1);
+ ++p;
+ chars_to_insert = "0";
+ insert_count = 1;
+ }
+ }
+ else if (!(*p == 'e' || *p == 'E')) {
+ /* Don't add ".0" if we have an exponent. */
+ if (digit_count == precision) {
+ /* issue 5864: don't add a trailing .0 in the case
+ where the '%g'-formatted result already has as many
+ significant digits as were requested. Switch to
+ exponential notation instead. */
+ convert_to_exp = 1;
+ /* no exponent, no point, and we shouldn't land here
+ for infs and nans, so we must be at the end of the
+ string. */
+ assert(*p == '\0');
+ }
+ else {
+ assert(precision == -1 || digit_count < precision);
+ chars_to_insert = ".0";
+ insert_count = 2;
+ }
+ }
+ if (insert_count) {
+ size_t buf_len = strlen(buffer);
+ if (buf_len + insert_count + 1 >= buf_size) {
+ /* If there is not enough room in the buffer
+ for the additional text, just skip it. It's
+ not worth generating an error over. */
+ }
+ else {
+ memmove(p + insert_count, p,
+ buffer + strlen(buffer) - p + 1);
+ memcpy(p, chars_to_insert, insert_count);
+ }
+ }
+ if (convert_to_exp) {
+ int written;
+ size_t buf_avail;
+ p = digits_start;
+ /* insert decimal point */
+ assert(digit_count >= 1);
+ memmove(p+2, p+1, digit_count); /* safe, but overwrites nul */
+ p[1] = '.';
+ p += digit_count+1;
+ assert(p <= buf_size+buffer);
+ buf_avail = buf_size+buffer-p;
+ if (buf_avail == 0)
+ return NULL;
+ /* Add exponent. It's okay to use lower case 'e': we only
+ arrive here as a result of using the empty format code or
+ repr/str builtins and those never want an upper case 'E' */
+ written = PyOS_snprintf(p, buf_avail, "e%+.02d", digit_count-1);
+ if (!(0 <= written &&
+ written < Py_SAFE_DOWNCAST(buf_avail, size_t, int)))
+ /* output truncated, or something else bad happened */
+ return NULL;
+ remove_trailing_zeros(buffer);
+ }
+ return buffer;
}
/* see FORMATBUFLEN in unicodeobject.c */
@@ -586,7 +586,7 @@
* @buffer: A buffer to place the resulting string in
* @buf_size: The length of the buffer.
* @format: The printf()-style format to use for the
- * code to use for converting.
+ * code to use for converting.
* @d: The #gdouble to convert
* @precision: The precision to use when formatting.
*
@@ -594,7 +594,7 @@
* decimal point. To format the number you pass in
* a printf()-style format string. Allowed conversion
* specifiers are 'e', 'E', 'f', 'F', 'g', 'G', and 'Z'.
- *
+ *
* 'Z' is the same as 'g', except it always has a decimal and
* at least one digit after the decimal.
*
@@ -602,83 +602,83 @@
* On failure returns NULL but does not set any Python exception.
**/
static char *
-_PyOS_ascii_formatd(char *buffer,
- size_t buf_size,
- const char *format,
- double d,
- int precision)
+_PyOS_ascii_formatd(char *buffer,
+ size_t buf_size,
+ const char *format,
+ double d,
+ int precision)
{
- char format_char;
- size_t format_len = strlen(format);
+ char format_char;
+ size_t format_len = strlen(format);
- /* Issue 2264: code 'Z' requires copying the format. 'Z' is 'g', but
- also with at least one character past the decimal. */
- char tmp_format[FLOAT_FORMATBUFLEN];
+ /* Issue 2264: code 'Z' requires copying the format. 'Z' is 'g', but
+ also with at least one character past the decimal. */
+ char tmp_format[FLOAT_FORMATBUFLEN];
- /* The last character in the format string must be the format char */
- format_char = format[format_len - 1];
+ /* The last character in the format string must be the format char */
+ format_char = format[format_len - 1];
- if (format[0] != '%')
- return NULL;
+ if (format[0] != '%')
+ return NULL;
- /* I'm not sure why this test is here. It's ensuring that the format
- string after the first character doesn't have a single quote, a
- lowercase l, or a percent. This is the reverse of the commented-out
- test about 10 lines ago. */
- if (strpbrk(format + 1, "'l%"))
- return NULL;
+ /* I'm not sure why this test is here. It's ensuring that the format
+ string after the first character doesn't have a single quote, a
+ lowercase l, or a percent. This is the reverse of the commented-out
+ test about 10 lines ago. */
+ if (strpbrk(format + 1, "'l%"))
+ return NULL;
- /* Also curious about this function is that it accepts format strings
- like "%xg", which are invalid for floats. In general, the
- interface to this function is not very good, but changing it is
- difficult because it's a public API. */
+ /* Also curious about this function is that it accepts format strings
+ like "%xg", which are invalid for floats. In general, the
+ interface to this function is not very good, but changing it is
+ difficult because it's a public API. */
- if (!(format_char == 'e' || format_char == 'E' ||
- format_char == 'f' || format_char == 'F' ||
- format_char == 'g' || format_char == 'G' ||
- format_char == 'Z'))
- return NULL;
+ if (!(format_char == 'e' || format_char == 'E' ||
+ format_char == 'f' || format_char == 'F' ||
+ format_char == 'g' || format_char == 'G' ||
+ format_char == 'Z'))
+ return NULL;
- /* Map 'Z' format_char to 'g', by copying the format string and
- replacing the final char with a 'g' */
- if (format_char == 'Z') {
- if (format_len + 1 >= sizeof(tmp_format)) {
- /* The format won't fit in our copy. Error out. In
- practice, this will never happen and will be
- detected by returning NULL */
- return NULL;
- }
- strcpy(tmp_format, format);
- tmp_format[format_len - 1] = 'g';
- format = tmp_format;
- }
+ /* Map 'Z' format_char to 'g', by copying the format string and
+ replacing the final char with a 'g' */
+ if (format_char == 'Z') {
+ if (format_len + 1 >= sizeof(tmp_format)) {
+ /* The format won't fit in our copy. Error out. In
+ practice, this will never happen and will be
+ detected by returning NULL */
+ return NULL;
+ }
+ strcpy(tmp_format, format);
+ tmp_format[format_len - 1] = 'g';
+ format = tmp_format;
+ }
- /* Have PyOS_snprintf do the hard work */
- PyOS_snprintf(buffer, buf_size, format, d);
+ /* Have PyOS_snprintf do the hard work */
+ PyOS_snprintf(buffer, buf_size, format, d);
- /* Do various fixups on the return string */
+ /* Do various fixups on the return string */
- /* Get the current locale, and find the decimal point string.
- Convert that string back to a dot. */
- change_decimal_from_locale_to_dot(buffer);
+ /* Get the current locale, and find the decimal point string.
+ Convert that string back to a dot. */
+ change_decimal_from_locale_to_dot(buffer);
- /* If an exponent exists, ensure that the exponent is at least
- MIN_EXPONENT_DIGITS digits, providing the buffer is large enough
- for the extra zeros. Also, if there are more than
- MIN_EXPONENT_DIGITS, remove as many zeros as possible until we get
- back to MIN_EXPONENT_DIGITS */
- ensure_minimum_exponent_length(buffer, buf_size);
+ /* If an exponent exists, ensure that the exponent is at least
+ MIN_EXPONENT_DIGITS digits, providing the buffer is large enough
+ for the extra zeros. Also, if there are more than
+ MIN_EXPONENT_DIGITS, remove as many zeros as possible until we get
+ back to MIN_EXPONENT_DIGITS */
+ ensure_minimum_exponent_length(buffer, buf_size);
- /* If format_char is 'Z', make sure we have at least one character
- after the decimal point (and make sure we have a decimal point);
- also switch to exponential notation in some edge cases where the
- extra character would produce more significant digits that we
- really want. */
- if (format_char == 'Z')
- buffer = ensure_decimal_point(buffer, buf_size, precision);
+ /* If format_char is 'Z', make sure we have at least one character
+ after the decimal point (and make sure we have a decimal point);
+ also switch to exponential notation in some edge cases where the
+ extra character would produce more significant digits that we
+ really want. */
+ if (format_char == 'Z')
+ buffer = ensure_decimal_point(buffer, buf_size, precision);
- return buffer;
+ return buffer;
}
/* The fallback code to use if _Py_dg_dtoa is not available. */
@@ -689,146 +689,146 @@
int flags,
int *type)
{
- char format[32];
- Py_ssize_t bufsize;
- char *buf;
- int t, exp;
- int upper = 0;
+ char format[32];
+ Py_ssize_t bufsize;
+ char *buf;
+ int t, exp;
+ int upper = 0;
- /* Validate format_code, and map upper and lower case */
- switch (format_code) {
- case 'e': /* exponent */
- case 'f': /* fixed */
- case 'g': /* general */
- break;
- case 'E':
- upper = 1;
- format_code = 'e';
- break;
- case 'F':
- upper = 1;
- format_code = 'f';
- break;
- case 'G':
- upper = 1;
- format_code = 'g';
- break;
- case 'r': /* repr format */
- /* Supplied precision is unused, must be 0. */
- if (precision != 0) {
- PyErr_BadInternalCall();
- return NULL;
- }
- /* The repr() precision (17 significant decimal digits) is the
- minimal number that is guaranteed to have enough precision
- so that if the number is read back in the exact same binary
- value is recreated. This is true for IEEE floating point
- by design, and also happens to work for all other modern
- hardware. */
- precision = 17;
- format_code = 'g';
- break;
- default:
- PyErr_BadInternalCall();
- return NULL;
- }
+ /* Validate format_code, and map upper and lower case */
+ switch (format_code) {
+ case 'e': /* exponent */
+ case 'f': /* fixed */
+ case 'g': /* general */
+ break;
+ case 'E':
+ upper = 1;
+ format_code = 'e';
+ break;
+ case 'F':
+ upper = 1;
+ format_code = 'f';
+ break;
+ case 'G':
+ upper = 1;
+ format_code = 'g';
+ break;
+ case 'r': /* repr format */
+ /* Supplied precision is unused, must be 0. */
+ if (precision != 0) {
+ PyErr_BadInternalCall();
+ return NULL;
+ }
+ /* The repr() precision (17 significant decimal digits) is the
+ minimal number that is guaranteed to have enough precision
+ so that if the number is read back in the exact same binary
+ value is recreated. This is true for IEEE floating point
+ by design, and also happens to work for all other modern
+ hardware. */
+ precision = 17;
+ format_code = 'g';
+ break;
+ default:
+ PyErr_BadInternalCall();
+ return NULL;
+ }
- /* Here's a quick-and-dirty calculation to figure out how big a buffer
- we need. In general, for a finite float we need:
+ /* Here's a quick-and-dirty calculation to figure out how big a buffer
+ we need. In general, for a finite float we need:
- 1 byte for each digit of the decimal significand, and
+ 1 byte for each digit of the decimal significand, and
- 1 for a possible sign
- 1 for a possible decimal point
- 2 for a possible [eE][+-]
- 1 for each digit of the exponent; if we allow 19 digits
- total then we're safe up to exponents of 2**63.
- 1 for the trailing nul byte
+ 1 for a possible sign
+ 1 for a possible decimal point
+ 2 for a possible [eE][+-]
+ 1 for each digit of the exponent; if we allow 19 digits
+ total then we're safe up to exponents of 2**63.
+ 1 for the trailing nul byte
- This gives a total of 24 + the number of digits in the significand,
- and the number of digits in the significand is:
+ This gives a total of 24 + the number of digits in the significand,
+ and the number of digits in the significand is:
- for 'g' format: at most precision, except possibly
- when precision == 0, when it's 1.
- for 'e' format: precision+1
- for 'f' format: precision digits after the point, at least 1
- before. To figure out how many digits appear before the point
- we have to examine the size of the number. If fabs(val) < 1.0
- then there will be only one digit before the point. If
- fabs(val) >= 1.0, then there are at most
+ for 'g' format: at most precision, except possibly
+ when precision == 0, when it's 1.
+ for 'e' format: precision+1
+ for 'f' format: precision digits after the point, at least 1
+ before. To figure out how many digits appear before the point
+ we have to examine the size of the number. If fabs(val) < 1.0
+ then there will be only one digit before the point. If
+ fabs(val) >= 1.0, then there are at most
- 1+floor(log10(ceiling(fabs(val))))
+ 1+floor(log10(ceiling(fabs(val))))
- digits before the point (where the 'ceiling' allows for the
- possibility that the rounding rounds the integer part of val
- up). A safe upper bound for the above quantity is
- 1+floor(exp/3), where exp is the unique integer such that 0.5
- <= fabs(val)/2**exp < 1.0. This exp can be obtained from
- frexp.
+ digits before the point (where the 'ceiling' allows for the
+ possibility that the rounding rounds the integer part of val
+ up). A safe upper bound for the above quantity is
+ 1+floor(exp/3), where exp is the unique integer such that 0.5
+ <= fabs(val)/2**exp < 1.0. This exp can be obtained from
+ frexp.
- So we allow room for precision+1 digits for all formats, plus an
- extra floor(exp/3) digits for 'f' format.
+ So we allow room for precision+1 digits for all formats, plus an
+ extra floor(exp/3) digits for 'f' format.
- */
+ */
- if (Py_IS_NAN(val) || Py_IS_INFINITY(val))
- /* 3 for 'inf'/'nan', 1 for sign, 1 for '\0' */
- bufsize = 5;
- else {
- bufsize = 25 + precision;
- if (format_code == 'f' && fabs(val) >= 1.0) {
- frexp(val, &exp);
- bufsize += exp/3;
- }
- }
+ if (Py_IS_NAN(val) || Py_IS_INFINITY(val))
+ /* 3 for 'inf'/'nan', 1 for sign, 1 for '\0' */
+ bufsize = 5;
+ else {
+ bufsize = 25 + precision;
+ if (format_code == 'f' && fabs(val) >= 1.0) {
+ frexp(val, &exp);
+ bufsize += exp/3;
+ }
+ }
- buf = PyMem_Malloc(bufsize);
- if (buf == NULL) {
- PyErr_NoMemory();
- return NULL;
- }
+ buf = PyMem_Malloc(bufsize);
+ if (buf == NULL) {
+ PyErr_NoMemory();
+ return NULL;
+ }
- /* Handle nan and inf. */
- if (Py_IS_NAN(val)) {
- strcpy(buf, "nan");
- t = Py_DTST_NAN;
- } else if (Py_IS_INFINITY(val)) {
- if (copysign(1., val) == 1.)
- strcpy(buf, "inf");
- else
- strcpy(buf, "-inf");
- t = Py_DTST_INFINITE;
- } else {
- t = Py_DTST_FINITE;
- if (flags & Py_DTSF_ADD_DOT_0)
- format_code = 'Z';
+ /* Handle nan and inf. */
+ if (Py_IS_NAN(val)) {
+ strcpy(buf, "nan");
+ t = Py_DTST_NAN;
+ } else if (Py_IS_INFINITY(val)) {
+ if (copysign(1., val) == 1.)
+ strcpy(buf, "inf");
+ else
+ strcpy(buf, "-inf");
+ t = Py_DTST_INFINITE;
+ } else {
+ t = Py_DTST_FINITE;
+ if (flags & Py_DTSF_ADD_DOT_0)
+ format_code = 'Z';
- PyOS_snprintf(format, sizeof(format), "%%%s.%i%c",
- (flags & Py_DTSF_ALT ? "#" : ""), precision,
- format_code);
- _PyOS_ascii_formatd(buf, bufsize, format, val, precision);
- }
+ PyOS_snprintf(format, sizeof(format), "%%%s.%i%c",
+ (flags & Py_DTSF_ALT ? "#" : ""), precision,
+ format_code);
+ _PyOS_ascii_formatd(buf, bufsize, format, val, precision);
+ }
- /* Add sign when requested. It's convenient (esp. when formatting
- complex numbers) to include a sign even for inf and nan. */
- if (flags & Py_DTSF_SIGN && buf[0] != '-') {
- size_t len = strlen(buf);
- /* the bufsize calculations above should ensure that we've got
- space to add a sign */
- assert((size_t)bufsize >= len+2);
- memmove(buf+1, buf, len+1);
- buf[0] = '+';
- }
- if (upper) {
- /* Convert to upper case. */
- char *p1;
- for (p1 = buf; *p1; p1++)
- *p1 = Py_TOUPPER(*p1);
- }
+ /* Add sign when requested. It's convenient (esp. when formatting
+ complex numbers) to include a sign even for inf and nan. */
+ if (flags & Py_DTSF_SIGN && buf[0] != '-') {
+ size_t len = strlen(buf);
+ /* the bufsize calculations above should ensure that we've got
+ space to add a sign */
+ assert((size_t)bufsize >= len+2);
+ memmove(buf+1, buf, len+1);
+ buf[0] = '+';
+ }
+ if (upper) {
+ /* Convert to upper case. */
+ char *p1;
+ for (p1 = buf; *p1; p1++)
+ *p1 = Py_TOUPPER(*p1);
+ }
- if (type)
- *type = t;
- return buf;
+ if (type)
+ *type = t;
+ return buf;
}
#else
@@ -843,14 +843,14 @@
/* The lengths of these are known to the code below, so don't change them */
static char *lc_float_strings[] = {
- "inf",
- "nan",
- "e",
+ "inf",
+ "nan",
+ "e",
};
static char *uc_float_strings[] = {
- "INF",
- "NAN",
- "E",
+ "INF",
+ "NAN",
+ "E",
};
@@ -874,9 +874,9 @@
be nonzero.
type, if non-NULL, will be set to one of these constants to identify
the type of the 'd' argument:
- Py_DTST_FINITE
- Py_DTST_INFINITE
- Py_DTST_NAN
+ Py_DTST_FINITE
+ Py_DTST_INFINITE
+ Py_DTST_NAN
Returns a PyMem_Malloc'd block of memory containing the resulting string,
or NULL on error. If NULL is returned, the Python error has been set.
@@ -884,315 +884,315 @@
static char *
format_float_short(double d, char format_code,
- int mode, Py_ssize_t precision,
- int always_add_sign, int add_dot_0_if_integer,
- int use_alt_formatting, char **float_strings, int *type)
+ int mode, Py_ssize_t precision,
+ int always_add_sign, int add_dot_0_if_integer,
+ int use_alt_formatting, char **float_strings, int *type)
{
- char *buf = NULL;
- char *p = NULL;
- Py_ssize_t bufsize = 0;
- char *digits, *digits_end;
- int decpt_as_int, sign, exp_len, exp = 0, use_exp = 0;
- Py_ssize_t decpt, digits_len, vdigits_start, vdigits_end;
- _Py_SET_53BIT_PRECISION_HEADER;
+ char *buf = NULL;
+ char *p = NULL;
+ Py_ssize_t bufsize = 0;
+ char *digits, *digits_end;
+ int decpt_as_int, sign, exp_len, exp = 0, use_exp = 0;
+ Py_ssize_t decpt, digits_len, vdigits_start, vdigits_end;
+ _Py_SET_53BIT_PRECISION_HEADER;
- /* _Py_dg_dtoa returns a digit string (no decimal point or exponent).
- Must be matched by a call to _Py_dg_freedtoa. */
- _Py_SET_53BIT_PRECISION_START;
- digits = _Py_dg_dtoa(d, mode, precision, &decpt_as_int, &sign,
- &digits_end);
- _Py_SET_53BIT_PRECISION_END;
+ /* _Py_dg_dtoa returns a digit string (no decimal point or exponent).
+ Must be matched by a call to _Py_dg_freedtoa. */
+ _Py_SET_53BIT_PRECISION_START;
+ digits = _Py_dg_dtoa(d, mode, precision, &decpt_as_int, &sign,
+ &digits_end);
+ _Py_SET_53BIT_PRECISION_END;
- decpt = (Py_ssize_t)decpt_as_int;
- if (digits == NULL) {
- /* The only failure mode is no memory. */
- PyErr_NoMemory();
- goto exit;
- }
- assert(digits_end != NULL && digits_end >= digits);
- digits_len = digits_end - digits;
+ decpt = (Py_ssize_t)decpt_as_int;
+ if (digits == NULL) {
+ /* The only failure mode is no memory. */
+ PyErr_NoMemory();
+ goto exit;
+ }
+ assert(digits_end != NULL && digits_end >= digits);
+ digits_len = digits_end - digits;
- if (digits_len && !Py_ISDIGIT(digits[0])) {
- /* Infinities and nans here; adapt Gay's output,
- so convert Infinity to inf and NaN to nan, and
- ignore sign of nan. Then return. */
+ if (digits_len && !Py_ISDIGIT(digits[0])) {
+ /* Infinities and nans here; adapt Gay's output,
+ so convert Infinity to inf and NaN to nan, and
+ ignore sign of nan. Then return. */
- /* ignore the actual sign of a nan */
- if (digits[0] == 'n' || digits[0] == 'N')
- sign = 0;
+ /* ignore the actual sign of a nan */
+ if (digits[0] == 'n' || digits[0] == 'N')
+ sign = 0;
- /* We only need 5 bytes to hold the result "+inf\0" . */
- bufsize = 5; /* Used later in an assert. */
- buf = (char *)PyMem_Malloc(bufsize);
- if (buf == NULL) {
- PyErr_NoMemory();
- goto exit;
- }
- p = buf;
+ /* We only need 5 bytes to hold the result "+inf\0" . */
+ bufsize = 5; /* Used later in an assert. */
+ buf = (char *)PyMem_Malloc(bufsize);
+ if (buf == NULL) {
+ PyErr_NoMemory();
+ goto exit;
+ }
+ p = buf;
- if (sign == 1) {
- *p++ = '-';
- }
- else if (always_add_sign) {
- *p++ = '+';
- }
- if (digits[0] == 'i' || digits[0] == 'I') {
- strncpy(p, float_strings[OFS_INF], 3);
- p += 3;
+ if (sign == 1) {
+ *p++ = '-';
+ }
+ else if (always_add_sign) {
+ *p++ = '+';
+ }
+ if (digits[0] == 'i' || digits[0] == 'I') {
+ strncpy(p, float_strings[OFS_INF], 3);
+ p += 3;
- if (type)
- *type = Py_DTST_INFINITE;
- }
- else if (digits[0] == 'n' || digits[0] == 'N') {
- strncpy(p, float_strings[OFS_NAN], 3);
- p += 3;
+ if (type)
+ *type = Py_DTST_INFINITE;
+ }
+ else if (digits[0] == 'n' || digits[0] == 'N') {
+ strncpy(p, float_strings[OFS_NAN], 3);
+ p += 3;
- if (type)
- *type = Py_DTST_NAN;
- }
- else {
- /* shouldn't get here: Gay's code should always return
- something starting with a digit, an 'I', or 'N' */
- strncpy(p, "ERR", 3);
- p += 3;
- assert(0);
- }
- goto exit;
- }
+ if (type)
+ *type = Py_DTST_NAN;
+ }
+ else {
+ /* shouldn't get here: Gay's code should always return
+ something starting with a digit, an 'I', or 'N' */
+ strncpy(p, "ERR", 3);
+ p += 3;
+ assert(0);
+ }
+ goto exit;
+ }
- /* The result must be finite (not inf or nan). */
- if (type)
- *type = Py_DTST_FINITE;
+ /* The result must be finite (not inf or nan). */
+ if (type)
+ *type = Py_DTST_FINITE;
- /* We got digits back, format them. We may need to pad 'digits'
- either on the left or right (or both) with extra zeros, so in
- general the resulting string has the form
+ /* We got digits back, format them. We may need to pad 'digits'
+ either on the left or right (or both) with extra zeros, so in
+ general the resulting string has the form
- [<sign>]<zeros><digits><zeros>[<exponent>]
+ [<sign>]<zeros><digits><zeros>[<exponent>]
- where either of the <zeros> pieces could be empty, and there's a
- decimal point that could appear either in <digits> or in the
- leading or trailing <zeros>.
+ where either of the <zeros> pieces could be empty, and there's a
+ decimal point that could appear either in <digits> or in the
+ leading or trailing <zeros>.
- Imagine an infinite 'virtual' string vdigits, consisting of the
- string 'digits' (starting at index 0) padded on both the left and
- right with infinite strings of zeros. We want to output a slice
+ Imagine an infinite 'virtual' string vdigits, consisting of the
+ string 'digits' (starting at index 0) padded on both the left and
+ right with infinite strings of zeros. We want to output a slice
- vdigits[vdigits_start : vdigits_end]
+ vdigits[vdigits_start : vdigits_end]
- of this virtual string. Thus if vdigits_start < 0 then we'll end
- up producing some leading zeros; if vdigits_end > digits_len there
- will be trailing zeros in the output. The next section of code
- determines whether to use an exponent or not, figures out the
- position 'decpt' of the decimal point, and computes 'vdigits_start'
- and 'vdigits_end'. */
- vdigits_end = digits_len;
- switch (format_code) {
- case 'e':
- use_exp = 1;
- vdigits_end = precision;
- break;
- case 'f':
- vdigits_end = decpt + precision;
- break;
- case 'g':
- if (decpt <= -4 || decpt >
- (add_dot_0_if_integer ? precision-1 : precision))
- use_exp = 1;
- if (use_alt_formatting)
- vdigits_end = precision;
- break;
- case 'r':
- /* convert to exponential format at 1e16. We used to convert
- at 1e17, but that gives odd-looking results for some values
- when a 16-digit 'shortest' repr is padded with bogus zeros.
- For example, repr(2e16+8) would give 20000000000000010.0;
- the true value is 20000000000000008.0. */
- if (decpt <= -4 || decpt > 16)
- use_exp = 1;
- break;
- default:
- PyErr_BadInternalCall();
- goto exit;
- }
+ of this virtual string. Thus if vdigits_start < 0 then we'll end
+ up producing some leading zeros; if vdigits_end > digits_len there
+ will be trailing zeros in the output. The next section of code
+ determines whether to use an exponent or not, figures out the
+ position 'decpt' of the decimal point, and computes 'vdigits_start'
+ and 'vdigits_end'. */
+ vdigits_end = digits_len;
+ switch (format_code) {
+ case 'e':
+ use_exp = 1;
+ vdigits_end = precision;
+ break;
+ case 'f':
+ vdigits_end = decpt + precision;
+ break;
+ case 'g':
+ if (decpt <= -4 || decpt >
+ (add_dot_0_if_integer ? precision-1 : precision))
+ use_exp = 1;
+ if (use_alt_formatting)
+ vdigits_end = precision;
+ break;
+ case 'r':
+ /* convert to exponential format at 1e16. We used to convert
+ at 1e17, but that gives odd-looking results for some values
+ when a 16-digit 'shortest' repr is padded with bogus zeros.
+ For example, repr(2e16+8) would give 20000000000000010.0;
+ the true value is 20000000000000008.0. */
+ if (decpt <= -4 || decpt > 16)
+ use_exp = 1;
+ break;
+ default:
+ PyErr_BadInternalCall();
+ goto exit;
+ }
- /* if using an exponent, reset decimal point position to 1 and adjust
- exponent accordingly.*/
- if (use_exp) {
- exp = decpt - 1;
- decpt = 1;
- }
- /* ensure vdigits_start < decpt <= vdigits_end, or vdigits_start <
- decpt < vdigits_end if add_dot_0_if_integer and no exponent */
- vdigits_start = decpt <= 0 ? decpt-1 : 0;
- if (!use_exp && add_dot_0_if_integer)
- vdigits_end = vdigits_end > decpt ? vdigits_end : decpt + 1;
- else
- vdigits_end = vdigits_end > decpt ? vdigits_end : decpt;
+ /* if using an exponent, reset decimal point position to 1 and adjust
+ exponent accordingly.*/
+ if (use_exp) {
+ exp = decpt - 1;
+ decpt = 1;
+ }
+ /* ensure vdigits_start < decpt <= vdigits_end, or vdigits_start <
+ decpt < vdigits_end if add_dot_0_if_integer and no exponent */
+ vdigits_start = decpt <= 0 ? decpt-1 : 0;
+ if (!use_exp && add_dot_0_if_integer)
+ vdigits_end = vdigits_end > decpt ? vdigits_end : decpt + 1;
+ else
+ vdigits_end = vdigits_end > decpt ? vdigits_end : decpt;
- /* double check inequalities */
- assert(vdigits_start <= 0 &&
- 0 <= digits_len &&
- digits_len <= vdigits_end);
- /* decimal point should be in (vdigits_start, vdigits_end] */
- assert(vdigits_start < decpt && decpt <= vdigits_end);
+ /* double check inequalities */
+ assert(vdigits_start <= 0 &&
+ 0 <= digits_len &&
+ digits_len <= vdigits_end);
+ /* decimal point should be in (vdigits_start, vdigits_end] */
+ assert(vdigits_start < decpt && decpt <= vdigits_end);
- /* Compute an upper bound how much memory we need. This might be a few
- chars too long, but no big deal. */
- bufsize =
- /* sign, decimal point and trailing 0 byte */
- 3 +
+ /* Compute an upper bound how much memory we need. This might be a few
+ chars too long, but no big deal. */
+ bufsize =
+ /* sign, decimal point and trailing 0 byte */
+ 3 +
- /* total digit count (including zero padding on both sides) */
- (vdigits_end - vdigits_start) +
+ /* total digit count (including zero padding on both sides) */
+ (vdigits_end - vdigits_start) +
- /* exponent "e+100", max 3 numerical digits */
- (use_exp ? 5 : 0);
+ /* exponent "e+100", max 3 numerical digits */
+ (use_exp ? 5 : 0);
- /* Now allocate the memory and initialize p to point to the start of
- it. */
- buf = (char *)PyMem_Malloc(bufsize);
- if (buf == NULL) {
- PyErr_NoMemory();
- goto exit;
- }
- p = buf;
+ /* Now allocate the memory and initialize p to point to the start of
+ it. */
+ buf = (char *)PyMem_Malloc(bufsize);
+ if (buf == NULL) {
+ PyErr_NoMemory();
+ goto exit;
+ }
+ p = buf;
- /* Add a negative sign if negative, and a plus sign if non-negative
- and always_add_sign is true. */
- if (sign == 1)
- *p++ = '-';
- else if (always_add_sign)
- *p++ = '+';
+ /* Add a negative sign if negative, and a plus sign if non-negative
+ and always_add_sign is true. */
+ if (sign == 1)
+ *p++ = '-';
+ else if (always_add_sign)
+ *p++ = '+';
- /* note that exactly one of the three 'if' conditions is true,
- so we include exactly one decimal point */
- /* Zero padding on left of digit string */
- if (decpt <= 0) {
- memset(p, '0', decpt-vdigits_start);
- p += decpt - vdigits_start;
- *p++ = '.';
- memset(p, '0', 0-decpt);
- p += 0-decpt;
- }
- else {
- memset(p, '0', 0-vdigits_start);
- p += 0 - vdigits_start;
- }
+ /* note that exactly one of the three 'if' conditions is true,
+ so we include exactly one decimal point */
+ /* Zero padding on left of digit string */
+ if (decpt <= 0) {
+ memset(p, '0', decpt-vdigits_start);
+ p += decpt - vdigits_start;
+ *p++ = '.';
+ memset(p, '0', 0-decpt);
+ p += 0-decpt;
+ }
+ else {
+ memset(p, '0', 0-vdigits_start);
+ p += 0 - vdigits_start;
+ }
- /* Digits, with included decimal point */
- if (0 < decpt && decpt <= digits_len) {
- strncpy(p, digits, decpt-0);
- p += decpt-0;
- *p++ = '.';
- strncpy(p, digits+decpt, digits_len-decpt);
- p += digits_len-decpt;
- }
- else {
- strncpy(p, digits, digits_len);
- p += digits_len;
- }
+ /* Digits, with included decimal point */
+ if (0 < decpt && decpt <= digits_len) {
+ strncpy(p, digits, decpt-0);
+ p += decpt-0;
+ *p++ = '.';
+ strncpy(p, digits+decpt, digits_len-decpt);
+ p += digits_len-decpt;
+ }
+ else {
+ strncpy(p, digits, digits_len);
+ p += digits_len;
+ }
- /* And zeros on the right */
- if (digits_len < decpt) {
- memset(p, '0', decpt-digits_len);
- p += decpt-digits_len;
- *p++ = '.';
- memset(p, '0', vdigits_end-decpt);
- p += vdigits_end-decpt;
- }
- else {
- memset(p, '0', vdigits_end-digits_len);
- p += vdigits_end-digits_len;
- }
+ /* And zeros on the right */
+ if (digits_len < decpt) {
+ memset(p, '0', decpt-digits_len);
+ p += decpt-digits_len;
+ *p++ = '.';
+ memset(p, '0', vdigits_end-decpt);
+ p += vdigits_end-decpt;
+ }
+ else {
+ memset(p, '0', vdigits_end-digits_len);
+ p += vdigits_end-digits_len;
+ }
- /* Delete a trailing decimal pt unless using alternative formatting. */
- if (p[-1] == '.' && !use_alt_formatting)
- p--;
+ /* Delete a trailing decimal pt unless using alternative formatting. */
+ if (p[-1] == '.' && !use_alt_formatting)
+ p--;
- /* Now that we've done zero padding, add an exponent if needed. */
- if (use_exp) {
- *p++ = float_strings[OFS_E][0];
- exp_len = sprintf(p, "%+.02d", exp);
- p += exp_len;
- }
+ /* Now that we've done zero padding, add an exponent if needed. */
+ if (use_exp) {
+ *p++ = float_strings[OFS_E][0];
+ exp_len = sprintf(p, "%+.02d", exp);
+ p += exp_len;
+ }
exit:
- if (buf) {
- *p = '\0';
- /* It's too late if this fails, as we've already stepped on
- memory that isn't ours. But it's an okay debugging test. */
- assert(p-buf < bufsize);
- }
- if (digits)
- _Py_dg_freedtoa(digits);
+ if (buf) {
+ *p = '\0';
+ /* It's too late if this fails, as we've already stepped on
+ memory that isn't ours. But it's an okay debugging test. */
+ assert(p-buf < bufsize);
+ }
+ if (digits)
+ _Py_dg_freedtoa(digits);
- return buf;
+ return buf;
}
PyAPI_FUNC(char *) PyOS_double_to_string(double val,
- char format_code,
- int precision,
- int flags,
- int *type)
+ char format_code,
+ int precision,
+ int flags,
+ int *type)
{
- char **float_strings = lc_float_strings;
- int mode;
+ char **float_strings = lc_float_strings;
+ int mode;
- /* Validate format_code, and map upper and lower case. Compute the
- mode and make any adjustments as needed. */
- switch (format_code) {
- /* exponent */
- case 'E':
- float_strings = uc_float_strings;
- format_code = 'e';
- /* Fall through. */
- case 'e':
- mode = 2;
- precision++;
- break;
+ /* Validate format_code, and map upper and lower case. Compute the
+ mode and make any adjustments as needed. */
+ switch (format_code) {
+ /* exponent */
+ case 'E':
+ float_strings = uc_float_strings;
+ format_code = 'e';
+ /* Fall through. */
+ case 'e':
+ mode = 2;
+ precision++;
+ break;
- /* fixed */
- case 'F':
- float_strings = uc_float_strings;
- format_code = 'f';
- /* Fall through. */
- case 'f':
- mode = 3;
- break;
+ /* fixed */
+ case 'F':
+ float_strings = uc_float_strings;
+ format_code = 'f';
+ /* Fall through. */
+ case 'f':
+ mode = 3;
+ break;
- /* general */
- case 'G':
- float_strings = uc_float_strings;
- format_code = 'g';
- /* Fall through. */
- case 'g':
- mode = 2;
- /* precision 0 makes no sense for 'g' format; interpret as 1 */
- if (precision == 0)
- precision = 1;
- break;
+ /* general */
+ case 'G':
+ float_strings = uc_float_strings;
+ format_code = 'g';
+ /* Fall through. */
+ case 'g':
+ mode = 2;
+ /* precision 0 makes no sense for 'g' format; interpret as 1 */
+ if (precision == 0)
+ precision = 1;
+ break;
- /* repr format */
- case 'r':
- mode = 0;
- /* Supplied precision is unused, must be 0. */
- if (precision != 0) {
- PyErr_BadInternalCall();
- return NULL;
- }
- break;
+ /* repr format */
+ case 'r':
+ mode = 0;
+ /* Supplied precision is unused, must be 0. */
+ if (precision != 0) {
+ PyErr_BadInternalCall();
+ return NULL;
+ }
+ break;
- default:
- PyErr_BadInternalCall();
- return NULL;
- }
+ default:
+ PyErr_BadInternalCall();
+ return NULL;
+ }
- return format_float_short(val, format_code, mode, precision,
- flags & Py_DTSF_SIGN,
- flags & Py_DTSF_ADD_DOT_0,
- flags & Py_DTSF_ALT,
- float_strings, type);
+ return format_float_short(val, format_code, mode, precision,
+ flags & Py_DTSF_SIGN,
+ flags & Py_DTSF_ADD_DOT_0,
+ flags & Py_DTSF_ALT,
+ float_strings, type);
}
#endif /* ifdef PY_NO_SHORT_FLOAT_REPR */