#include <Python.h>

#include "pycore_dtoa.h"

#include "pycore_pymath.h" // _Py_SET_53BIT_PRECISION_START

#include <locale.h>

static int

case_insensitive_match(const char *s, const char *t)

{

while(*t && Py_TOLOWER(*s) == *t) {

s++;

t++;

}

return *t ? 0 : 1;

}

#ifndef PY_NO_SHORT_FLOAT_REPR

_Py_parse_inf_or_nan(const char *p, char **endptr)

{

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 = _Py_dg_infinity(negate);

}

else if (case_insensitive_match(s, "nan")) {

s += 3;

retval = _Py_dg_stdnan(negate);

}

else {

s = p;

retval = -1.0;

}

*endptr = (char *)s;

return retval;

}

_Py_parse_inf_or_nan(const char *p, char **endptr)

{

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;

}

#ifdef Py_NAN

else if (case_insensitive_match(s, "nan")) {

s += 3;

retval = negate ? -Py_NAN : Py_NAN;

}

else {

s = p;

retval = -1.0;

}

*endptr = (char *)s;

return retval;

}

#ifndef PY_NO_SHORT_FLOAT_REPR

static double

_PyOS_ascii_strtod(const char *nptr, char **endptr)

{

double result;

_Py_SET_53BIT_PRECISION_HEADER;

assert(nptr != NULL);

/* Set errno to zero, so that we can distinguish zero results

errno = 0;

_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);

return result;

}

static double

_PyOS_ascii_strtod(const char *nptr, char **endptr)

{

char *fail_pos;

double val;

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);

fail_pos = NULL;

locale_data = localeconv();

decimal_point = locale_data->decimal_point;

decimal_point_len = strlen(decimal_point);

assert(decimal_point_len != 0);

decimal_point_pos = NULL;

/* 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

errno = 0;

/* We process the optional sign manually, then pass the remainder to

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

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;

digits_pos = p;

if (decimal_point[0] != '.' ||

decimal_point[1] != 0)

{

/* Look for a '.' in the input; if present, it'll need to be

while (Py_ISDIGIT(*p))

p++;

if (*p == '.')

{

decimal_point_pos = 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

}

if (decimal_point_pos) {

char *copy, *c;

/* Create a copy of the input, with the '.' converted to the

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;

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);

}

PyMem_Free(copy);

}

else {

val = strtod(digits_pos, &fail_pos);

}

if (fail_pos == digits_pos)

goto invalid_string;

if (negate && fail_pos != nptr)

val = -val;

*endptr = fail_pos;

return val;

invalid_string:

*endptr = (char*)nptr;

errno = EINVAL;

return -1.0;

}

PyOS_string_to_double(const char *s,

char **endptr,

PyObject *overflow_exception)

{

double x, result=-1.0;

char *fail_pos;

errno = 0;

x = _PyOS_ascii_strtod(s, &fail_pos);

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;

}

PyObject *

_Py_string_to_number_with_underscores(

const char *s, Py_ssize_t orig_len, const char *what, PyObject *obj, void *arg,

PyObject *(*innerfunc)(const char *, Py_ssize_t, void *))

{

char prev;

const char *p, *last;

char *dup, *end;

PyObject *result;

assert(s[orig_len] == '\0');

if (strchr(s, '_') == NULL) {

return innerfunc(s, orig_len, arg);

}

dup = PyMem_Malloc(orig_len + 1);

if (dup == NULL) {

return PyErr_NoMemory();

}

end = dup;

prev = '\0';

last = s + orig_len;

for (p = s; *p; p++) {

if (*p == '_') {

/* Underscores are only allowed after digits. */

if (!(prev >= '0' && prev <= '9')) {

goto error;

}

}

else {

*end++ = *p;

/* Underscores are only allowed before digits. */

if (prev == '_' && !(*p >= '0' && *p <= '9')) {

goto error;

}

}

prev = *p;

}

/* Underscores are not allowed at the end. */

if (prev == '_') {

goto error;

}

/* No embedded NULs allowed. */

if (p != last) {

goto error;

}

*end = '\0';

result = innerfunc(dup, end - dup, arg);

PyMem_Free(dup);

return result;

error:

PyMem_Free(dup);

PyErr_Format(PyExc_ValueError,

"could not convert string to %s: "

"%R", what, obj);

return NULL;

}

#ifdef PY_NO_SHORT_FLOAT_REPR

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;

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;

}

}

}

}

#define MIN_EXPONENT_DIGITS 2

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;

/* Skip over the exponent and the sign. */

p += 2;

/* Find the end of the exponent, keeping track of leading

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,

}

else if (exponent_digit_cnt > MIN_EXPONENT_DIGITS) {

int extra_zeros_cnt;

/* There are more than 2 digits in the exponent. See

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

assert(extra_zeros_cnt >= 0);

/* Add one to significant_digit_cnt to copy the

memmove(start,

start + extra_zeros_cnt,

significant_digit_cnt + 1);

}

else {

/* If there are fewer than 2 digits, add zeros

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);

}

}

}

}

Py_LOCAL_INLINE(void)

remove_trailing_zeros(char *buffer)

{

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;

/* 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 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;

memmove(new_fraction_end, old_fraction_end, end-old_fraction_end);

}

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;

const char *chars_to_insert;

char *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

++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

}

else {

/* We have a decimal point, but no following

/* 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

convert_to_exp = 1;

/* no exponent, no point, and we shouldn't land here

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

}

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

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;

}

#define FLOAT_FORMATBUFLEN 120

static char *

_PyOS_ascii_formatd(char *buffer,

int precision)

{

char format_char;

size_t format_len = strlen(format);

/* Issue 2264: code 'Z' requires copying the format. 'Z' is 'g', but

char tmp_format[FLOAT_FORMATBUFLEN];

/* The last character in the format string must be the format char */

format_char = format[format_len - 1];

if (format[0] != '%')

return NULL;

/* I'm not sure why this test is here. It's ensuring that the format

if (strpbrk(format + 1, "'l%"))

return NULL;

/* Also curious about this function is that it accepts format strings

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

if (format_char == 'Z') {

if (format_len + 1 >= sizeof(tmp_format)) {

/* The format won't fit in our copy. Error out. In

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);

/* Do various fixups on the return string */

/* Get the current locale, and find the decimal point string.

change_decimal_from_locale_to_dot(buffer);

/* If an exponent exists, ensure that the exponent is at least

ensure_minimum_exponent_length(buffer, buf_size);

/* If format_char is 'Z', make sure we have at least one character

if (format_char == 'Z')

buffer = ensure_decimal_point(buffer, buf_size, precision);

return buffer;

}

char * PyOS_double_to_string(double val,

int *type)

{

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

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

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;

}

/* 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);

}

/* Add sign when requested. It's convenient (esp. when formatting

if (flags & Py_DTSF_SIGN && buf[0] != '-') {

size_t len = strlen(buf);

/* the bufsize calculations above should ensure that we've got

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;

}

#define OFS_INF 0

#define OFS_NAN 1

#define OFS_E 2

static const char * const lc_float_strings[] = {

"inf",

"nan",

"e",

};

static const char * const uc_float_strings[] = {

"INF",

"NAN",

"E",

};

static char *

format_float_short(double d, char format_code,