/* implements the unicode (as opposed to string) version of the

built-in formatters for string, int, float. that is, the versions

of int.__float__, etc., that take and return unicode objects */

#include "Python.h"

#include "pycore_fileutils.h" // _Py_GetLocaleconvNumeric()

#include "pycore_long.h" // _PyLong_FormatWriter()

#include "pycore_unicodeobject.h" // PyUnicode_MAX_CHAR_VALUE()

#include <locale.h>

/* _PyUnicode_InsertThousandsGrouping() helper functions */

typedef struct {

const char *grouping;

char previous;

Py_ssize_t i; /* Where we're currently pointing in grouping. */

} GroupGenerator;

static void

GroupGenerator_init(GroupGenerator *self, const char *grouping)

{

self->grouping = grouping;

self->i = 0;

self->previous = 0;

}

/* Returns the next grouping, or 0 to signify end. */

static Py_ssize_t

GroupGenerator_next(GroupGenerator *self)

{

/* Note that we don't really do much error checking here. If a

grouping string contains just CHAR_MAX, for example, then just

terminate the generator. That shouldn't happen, but at least we

fail gracefully. */

switch (self->grouping[self->i]) {

case 0:

return self->previous;

case CHAR_MAX:

/* Stop the generator. */

return 0;

default: {

char ch = self->grouping[self->i];

self->previous = ch;

self->i++;

return (Py_ssize_t)ch;

}

}

}

/* Fill in some digits, leading zeros, and thousands separator. All

are optional, depending on when we're called. */

static void

InsertThousandsGrouping_fill(_PyUnicodeWriter *writer, Py_ssize_t *buffer_pos,

PyObject *digits, Py_ssize_t *digits_pos,

Py_ssize_t n_chars, Py_ssize_t n_zeros,

PyObject *thousands_sep, Py_ssize_t thousands_sep_len,

Py_UCS4 *maxchar, int forward)

{

if (!writer) {

/* if maxchar > 127, maxchar is already set */

if (*maxchar == 127 && thousands_sep) {

Py_UCS4 maxchar2 = PyUnicode_MAX_CHAR_VALUE(thousands_sep);

*maxchar = Py_MAX(*maxchar, maxchar2);

}

return;

}

if (thousands_sep) {

if (!forward) {

*buffer_pos -= thousands_sep_len;

}

/* Copy the thousands_sep chars into the buffer. */

_PyUnicode_FastCopyCharacters(writer->buffer, *buffer_pos,

thousands_sep, 0,

thousands_sep_len);

if (forward) {

*buffer_pos += thousands_sep_len;

}

}

if (!forward) {

*buffer_pos -= n_chars;

*digits_pos -= n_chars;

}

_PyUnicode_FastCopyCharacters(writer->buffer, *buffer_pos,

digits, *digits_pos,

n_chars);

if (forward) {

*buffer_pos += n_chars;

*digits_pos += n_chars;

}

if (n_zeros) {

if (!forward) {

*buffer_pos -= n_zeros;

}

int kind = PyUnicode_KIND(writer->buffer);

void *data = PyUnicode_DATA(writer->buffer);

_PyUnicode_Fill(kind, data, '0', *buffer_pos, n_zeros);

if (forward) {

*buffer_pos += n_zeros;

}

}

}

/**

* InsertThousandsGrouping:

* @writer: Unicode writer.

* @n_buffer: Number of characters in @buffer.

* @digits: Digits we're reading from. If count is non-NULL, this is unused.

* @d_pos: Start of digits string.

* @n_digits: The number of digits in the string, in which we want

* to put the grouping chars.

* @min_width: The minimum width of the digits in the output string.

* Output will be zero-padded on the left to fill.

* @grouping: see definition in localeconv().

* @thousands_sep: see definition in localeconv().

*

* There are 2 modes: counting and filling. If @writer is NULL,

* we are in counting mode, else filling mode.

* If counting, the required buffer size is returned.

* If filling, we know the buffer will be large enough, so we don't

* need to pass in the buffer size.

* Inserts thousand grouping characters (as defined by grouping and

* thousands_sep) into @writer.

*

* Return value: -1 on error, number of characters otherwise.

**/

static Py_ssize_t

_PyUnicode_InsertThousandsGrouping(

_PyUnicodeWriter *writer,

Py_ssize_t n_buffer,

PyObject *digits,

Py_ssize_t d_pos,

Py_ssize_t n_digits,

Py_ssize_t min_width,

const char *grouping,

PyObject *thousands_sep,

Py_UCS4 *maxchar,

int forward)

{

min_width = Py_MAX(0, min_width);

if (writer) {

assert(digits != NULL);

assert(maxchar == NULL);

}

else {

assert(digits == NULL);

assert(maxchar != NULL);

}

assert(0 <= d_pos);

assert(0 <= n_digits);

assert(grouping != NULL);

Py_ssize_t count = 0;

Py_ssize_t n_zeros;

int loop_broken = 0;

int use_separator = 0; /* First time through, don't append the

separator. They only go between

groups. */

Py_ssize_t buffer_pos;

Py_ssize_t digits_pos;

Py_ssize_t len;

Py_ssize_t n_chars;

Py_ssize_t remaining = n_digits; /* Number of chars remaining to

be looked at */

/* A generator that returns all of the grouping widths, until it

returns 0. */

GroupGenerator groupgen;

GroupGenerator_init(&groupgen, grouping);

const Py_ssize_t thousands_sep_len = PyUnicode_GET_LENGTH(thousands_sep);

/* if digits are not grouped, thousands separator

should be an empty string */

assert(!(grouping[0] == CHAR_MAX && thousands_sep_len != 0));

digits_pos = d_pos + (forward ? 0 : n_digits);

if (writer) {

buffer_pos = writer->pos + (forward ? 0 : n_buffer);

assert(buffer_pos <= PyUnicode_GET_LENGTH(writer->buffer));

assert(digits_pos <= PyUnicode_GET_LENGTH(digits));

}

else {

buffer_pos = forward ? 0 : n_buffer;

}

if (!writer) {

*maxchar = 127;

}

while ((len = GroupGenerator_next(&groupgen)) > 0) {

len = Py_MIN(len, Py_MAX(Py_MAX(remaining, min_width), 1));

n_zeros = Py_MAX(0, len - remaining);

n_chars = Py_MAX(0, Py_MIN(remaining, len));

/* Use n_zero zero's and n_chars chars */

/* Count only, don't do anything. */

count += (use_separator ? thousands_sep_len : 0) + n_zeros + n_chars;

/* Copy into the writer. */

InsertThousandsGrouping_fill(writer, &buffer_pos,

digits, &digits_pos,

n_chars, n_zeros,

use_separator ? thousands_sep : NULL,

thousands_sep_len, maxchar, forward);

/* Use a separator next time. */

use_separator = 1;

remaining -= n_chars;

min_width -= len;

if (remaining <= 0 && min_width <= 0) {

loop_broken = 1;

break;

}

min_width -= thousands_sep_len;

}

if (!loop_broken) {

/* We left the loop without using a break statement. */

len = Py_MAX(Py_MAX(remaining, min_width), 1);

n_zeros = Py_MAX(0, len - remaining);

n_chars = Py_MAX(0, Py_MIN(remaining, len));

/* Use n_zero zero's and n_chars chars */

count += (use_separator ? thousands_sep_len : 0) + n_zeros + n_chars;

/* Copy into the writer. */

InsertThousandsGrouping_fill(writer, &buffer_pos,

digits, &digits_pos,

n_chars, n_zeros,

use_separator ? thousands_sep : NULL,

thousands_sep_len, maxchar, forward);

}

return count;

}

/* Raises an exception about an unknown presentation type for this

* type. */

static void

unknown_presentation_type(Py_UCS4 presentation_type,

const char* type_name)

{

/* %c might be out-of-range, hence the two cases. */

if (presentation_type > 32 && presentation_type < 128)

PyErr_Format(PyExc_ValueError,

"Unknown format code '%c' "

"for object of type '%.200s'",

(char)presentation_type,

type_name);

else

PyErr_Format(PyExc_ValueError,

"Unknown format code '\\x%x' "

"for object of type '%.200s'",

(unsigned int)presentation_type,

type_name);

}

static void

invalid_thousands_separator_type(char specifier, Py_UCS4 presentation_type)

{

assert(specifier == ',' || specifier == '_');

if (presentation_type > 32 && presentation_type < 128)

PyErr_Format(PyExc_ValueError,

"Cannot specify '%c' with '%c'.",

specifier, (char)presentation_type);

else

PyErr_Format(PyExc_ValueError,

"Cannot specify '%c' with '\\x%x'.",

specifier, (unsigned int)presentation_type);

}

static void

invalid_comma_and_underscore(void)

{

PyErr_Format(PyExc_ValueError, "Cannot specify both ',' and '_'.");

}

/*

get_integer consumes 0 or more decimal digit characters from an

input string, updates *result with the corresponding positive

integer, and returns the number of digits consumed.

returns -1 on error.

*/

static int

get_integer(PyObject *str, Py_ssize_t *ppos, Py_ssize_t end,

Py_ssize_t *result)

{

Py_ssize_t accumulator, digitval, pos = *ppos;

int numdigits;

int kind = PyUnicode_KIND(str);

const void *data = PyUnicode_DATA(str);

accumulator = numdigits = 0;

for (; pos < end; pos++, numdigits++) {

digitval = Py_UNICODE_TODECIMAL(PyUnicode_READ(kind, data, pos));

if (digitval < 0)

break;

/*

Detect possible overflow before it happens:

accumulator * 10 + digitval > PY_SSIZE_T_MAX if and only if

accumulator > (PY_SSIZE_T_MAX - digitval) / 10.

*/

if (accumulator > (PY_SSIZE_T_MAX - digitval) / 10) {

PyErr_Format(PyExc_ValueError,

"Too many decimal digits in format string");

*ppos = pos;

return -1;

}

accumulator = accumulator * 10 + digitval;

}

*ppos = pos;

*result = accumulator;

return numdigits;

}

/************************************************************************/

/*********** standard format specifier parsing **************************/

/************************************************************************/

/* returns true if this character is a specifier alignment token */

Py_LOCAL_INLINE(int)

is_alignment_token(Py_UCS4 c)

{

switch (c) {

case '<': case '>': case '=': case '^':

return 1;

default:

return 0;

}

}

/* returns true if this character is a sign element */

Py_LOCAL_INLINE(int)

is_sign_element(Py_UCS4 c)

{

switch (c) {

case ' ': case '+': case '-':

return 1;

default:

return 0;

}

}

/* Locale type codes. LT_NO_LOCALE must be zero. */

enum LocaleType {

LT_NO_LOCALE = 0,

LT_DEFAULT_LOCALE = ',',

LT_UNDERSCORE_LOCALE = '_',

LT_UNDER_FOUR_LOCALE,

LT_CURRENT_LOCALE

};

typedef struct {

Py_UCS4 fill_char;

Py_UCS4 align;

int alternate;

int no_neg_0;

Py_UCS4 sign;

Py_ssize_t width;

enum LocaleType thousands_separators;

Py_ssize_t precision;

enum LocaleType frac_thousands_separator;

Py_UCS4 type;

} InternalFormatSpec;

/*

ptr points to the start of the format_spec, end points just past its end.

fills in format with the parsed information.

returns 1 on success, 0 on failure.

if failure, sets the exception

*/

static int

parse_internal_render_format_spec(PyObject *obj,

PyObject *format_spec,

Py_ssize_t start, Py_ssize_t end,

InternalFormatSpec *format,

char default_type,

char default_align)

{

Py_ssize_t pos = start;

int kind = PyUnicode_KIND(format_spec);

const void *data = PyUnicode_DATA(format_spec);

/* end-pos is used throughout this code to specify the length of

the input string */

#define READ_spec(index) PyUnicode_READ(kind, data, index)

Py_ssize_t consumed;

int align_specified = 0;

int fill_char_specified = 0;

format->fill_char = ' ';

format->align = default_align;

format->alternate = 0;

format->no_neg_0 = 0;

format->sign = '\0';

format->width = -1;

format->thousands_separators = LT_NO_LOCALE;

format->frac_thousands_separator = LT_NO_LOCALE;

format->precision = -1;

format->type = default_type;

/* If the second char is an alignment token,

then parse the fill char */

if (end-pos >= 2 && is_alignment_token(READ_spec(pos+1))) {

format->align = READ_spec(pos+1);

format->fill_char = READ_spec(pos);

fill_char_specified = 1;

align_specified = 1;

pos += 2;

}

else if (end-pos >= 1 && is_alignment_token(READ_spec(pos))) {

format->align = READ_spec(pos);

align_specified = 1;

++pos;

}

/* Parse the various sign options */

if (end-pos >= 1 && is_sign_element(READ_spec(pos))) {

format->sign = READ_spec(pos);

++pos;

}

/* If the next character is z, request coercion of negative 0.

Applies only to floats. */

if (end-pos >= 1 && READ_spec(pos) == 'z') {

format->no_neg_0 = 1;

++pos;

}

/* If the next character is #, we're in alternate mode. This only

applies to integers. */

if (end-pos >= 1 && READ_spec(pos) == '#') {

format->alternate = 1;

++pos;

}

/* The special case for 0-padding (backwards compat) */

if (!fill_char_specified && end-pos >= 1 && READ_spec(pos) == '0') {

format->fill_char = '0';

if (!align_specified && default_align == '>') {

format->align = '=';

}

++pos;

}

consumed = get_integer(format_spec, &pos, end, &format->width);

if (consumed == -1)

/* Overflow error. Exception already set. */

return 0;

/* If consumed is 0, we didn't consume any characters for the

width. In that case, reset the width to -1, because

get_integer() will have set it to zero. -1 is how we record

that the width wasn't specified. */

if (consumed == 0)

format->width = -1;

/* Comma signifies add thousands separators */

if (end-pos && READ_spec(pos) == ',') {

format->thousands_separators = LT_DEFAULT_LOCALE;

++pos;

}

/* Underscore signifies add thousands separators */

if (end-pos && READ_spec(pos) == '_') {

if (format->thousands_separators != LT_NO_LOCALE) {

invalid_comma_and_underscore();

return 0;

}

format->thousands_separators = LT_UNDERSCORE_LOCALE;

++pos;

}

if (end-pos && READ_spec(pos) == ',') {

if (format->thousands_separators == LT_UNDERSCORE_LOCALE) {

invalid_comma_and_underscore();

return 0;

}

}

/* Parse field precision */

if (end-pos && READ_spec(pos) == '.') {

++pos;

consumed = get_integer(format_spec, &pos, end, &format->precision);

if (consumed == -1)

/* Overflow error. Exception already set. */

return 0;

if (end-pos && READ_spec(pos) == ',') {

if (consumed == 0) {

format->precision = -1;

}

format->frac_thousands_separator = LT_DEFAULT_LOCALE;

++pos;

++consumed;

}

if (end-pos && READ_spec(pos) == '_') {

if (format->frac_thousands_separator != LT_NO_LOCALE) {

invalid_comma_and_underscore();

return 0;

}

if (consumed == 0) {

format->precision = -1;

}

format->frac_thousands_separator = LT_UNDERSCORE_LOCALE;

++pos;

++consumed;

}

if (end-pos && READ_spec(pos) == ',') {

if (format->frac_thousands_separator == LT_UNDERSCORE_LOCALE) {

invalid_comma_and_underscore();

return 0;

}

}

/* Not having a precision or underscore/comma after a dot

is an error. */

if (consumed == 0) {

PyErr_Format(PyExc_ValueError,

"Format specifier missing precision");

return 0;

}

}

/* Finally, parse the type field. */

if (end-pos > 1) {

/* More than one char remains, so this is an invalid format

specifier. */

/* Create a temporary object that contains the format spec we're

operating on. It's format_spec[start:end] (in Python syntax). */

PyObject* actual_format_spec = PyUnicode_FromKindAndData(kind,

(char*)data + kind*start,

end-start);

if (actual_format_spec != NULL) {

PyErr_Format(PyExc_ValueError,

"Invalid format specifier '%U' for object of type '%.200s'",

actual_format_spec, Py_TYPE(obj)->tp_name);

Py_DECREF(actual_format_spec);

}

return 0;

}

if (end-pos == 1) {

format->type = READ_spec(pos);

++pos;

}

/* Do as much validating as we can, just by looking at the format

specifier. Do not take into account what type of formatting

we're doing (int, float, string). */

if (format->thousands_separators) {

switch (format->type) {

case 'd':

case 'e':

case 'f':

case 'g':

case 'E':

case 'G':

case '%':

case 'F':

case '\0':

/* These are allowed. See PEP 378.*/

break;

case 'b':

case 'o':

case 'x':

case 'X':

/* Underscores are allowed in bin/oct/hex. See PEP 515. */

if (format->thousands_separators == LT_UNDERSCORE_LOCALE) {

/* Every four digits, not every three, in bin/oct/hex. */

format->thousands_separators = LT_UNDER_FOUR_LOCALE;

break;

}

_Py_FALLTHROUGH;

default:

invalid_thousands_separator_type(format->thousands_separators, format->type);

return 0;

}

}

if (format->type == 'n'

&& format->frac_thousands_separator != LT_NO_LOCALE)

{

invalid_thousands_separator_type(format->frac_thousands_separator,

format->type);

return 0;

}

assert (format->align <= 127);

assert (format->sign <= 127);

return 1;

}

/* Calculate the padding needed. */

static void

calc_padding(Py_ssize_t nchars, Py_ssize_t width, Py_UCS4 align,

Py_ssize_t *n_lpadding, Py_ssize_t *n_rpadding,

Py_ssize_t *n_total)

{

if (width >= 0) {

if (nchars > width)

*n_total = nchars;

else

*n_total = width;

}

else {

/* not specified, use all of the chars and no more */

*n_total = nchars;

}

/* Figure out how much leading space we need, based on the

aligning */

if (align == '>')

*n_lpadding = *n_total - nchars;

else if (align == '^')

*n_lpadding = (*n_total - nchars) / 2;

else if (align == '<' || align == '=')

*n_lpadding = 0;

else {

/* We should never have an unspecified alignment. */

Py_UNREACHABLE();

}

*n_rpadding = *n_total - nchars - *n_lpadding;

}

/* Do the padding, and return a pointer to where the caller-supplied

content goes. */

static int

fill_padding(_PyUnicodeWriter *writer,

Py_ssize_t nchars,

Py_UCS4 fill_char, Py_ssize_t n_lpadding,

Py_ssize_t n_rpadding)

{

Py_ssize_t pos;

/* Pad on left. */

if (n_lpadding) {

pos = writer->pos;

_PyUnicode_FastFill(writer->buffer, pos, n_lpadding, fill_char);

}

/* Pad on right. */

if (n_rpadding) {

pos = writer->pos + nchars + n_lpadding;

_PyUnicode_FastFill(writer->buffer, pos, n_rpadding, fill_char);

}

/* Pointer to the user content. */

writer->pos += n_lpadding;

return 0;

}

/************************************************************************/

/*********** common routines for numeric formatting *********************/

/************************************************************************/

/* Locale info needed for formatting integers and the part of floats

before and including the decimal. Note that locales only support

8-bit chars, not unicode. */

typedef struct {

PyObject *decimal_point;

PyObject *thousands_sep;

PyObject *frac_thousands_sep;

const char *grouping;

char *grouping_buffer;

} LocaleInfo;

#define LocaleInfo_STATIC_INIT {0, 0, 0, 0}

/* describes the layout for an integer, see the comment in

calc_number_widths() for details */

typedef struct {

Py_ssize_t n_lpadding;

Py_ssize_t n_prefix;

Py_ssize_t n_spadding;

Py_ssize_t n_rpadding;

char sign;

Py_ssize_t n_sign; /* number of digits needed for sign (0/1) */

Py_ssize_t n_grouped_digits; /* Space taken up by the digits, including

any grouping chars. */

Py_ssize_t n_decimal; /* 0 if only an integer */

Py_ssize_t n_remainder; /* Digits in decimal and/or exponent part,

excluding the decimal itself, if

present. */

Py_ssize_t n_frac;

Py_ssize_t n_grouped_frac_digits;

/* These 2 are not the widths of fields, but are needed by

STRINGLIB_GROUPING. */

Py_ssize_t n_digits; /* The number of digits before a decimal

or exponent. */

Py_ssize_t n_min_width; /* The min_width we used when we computed

the n_grouped_digits width. */

} NumberFieldWidths;

/* Given a number of the form:

digits[remainder]

where ptr points to the start and end points to the end, find where

the integer part ends. This could be a decimal, an exponent, both,

or neither.

If a decimal point is present, set *has_decimal and increment

remainder beyond it.

Results are undefined (but shouldn't crash) for improperly

formatted strings.

*/

static void

parse_number(PyObject *s, Py_ssize_t pos, Py_ssize_t end,

Py_ssize_t *n_remainder, Py_ssize_t *n_frac, int *has_decimal)

{

Py_ssize_t frac;

int kind = PyUnicode_KIND(s);

const void *data = PyUnicode_DATA(s);

while (pos<end && Py_ISDIGIT(PyUnicode_READ(kind, data, pos))) {

++pos;

}

frac = pos;

/* Does remainder start with a decimal point? */

*has_decimal = pos<end && PyUnicode_READ(kind, data, frac) == '.';

/* Skip the decimal point. */

if (*has_decimal) {

frac++;

pos++;

}

while (pos<end && Py_ISDIGIT(PyUnicode_READ(kind, data, pos))) {

++pos;

}

*n_frac = pos - frac;

*n_remainder = end - pos;

}

/* not all fields of format are used. for example, precision is

unused. should this take discrete params in order to be more clear

about what it does? or is passing a single format parameter easier

and more efficient enough to justify a little obfuscation?

Return -1 on error. */

static Py_ssize_t

calc_number_widths(NumberFieldWidths *spec, Py_ssize_t n_prefix,

Py_UCS4 sign_char, Py_ssize_t n_start,

Py_ssize_t n_end, Py_ssize_t n_remainder, Py_ssize_t n_frac,

int has_decimal, const LocaleInfo *locale,

const InternalFormatSpec *format, Py_UCS4 *maxchar)

{

Py_ssize_t n_non_digit_non_padding;

Py_ssize_t n_padding;

spec->n_digits = n_end - n_start - n_frac - n_remainder - (has_decimal?1:0);

spec->n_lpadding = 0;

spec->n_prefix = n_prefix;

spec->n_decimal = has_decimal ? PyUnicode_GET_LENGTH(locale->decimal_point) : 0;

spec->n_remainder = n_remainder;

spec->n_frac = n_frac;

spec->n_spadding = 0;

spec->n_rpadding = 0;

spec->sign = '\0';

spec->n_sign = 0;

/* the output will look like:

| |

| <lpadding> <sign> <prefix> <spadding> <grouped_digits> <decimal> <remainder> <rpadding> |

| |

sign is computed from format->sign and the actual

sign of the number

prefix is given (it's for the '0x' prefix)

digits is already known

the total width is either given, or computed from the

actual digits

only one of lpadding, spadding, and rpadding can be non-zero,

and it's calculated from the width and other fields

*/

/* compute the various parts we're going to write */

switch (format->sign) {

case '+':

/* always put a + or - */

spec->n_sign = 1;

spec->sign = (sign_char == '-' ? '-' : '+');

break;

case ' ':

spec->n_sign = 1;

spec->sign = (sign_char == '-' ? '-' : ' ');

break;

default:

/* Not specified, or the default (-) */

if (sign_char == '-') {

spec->n_sign = 1;

spec->sign = '-';

}

}

if (spec->n_frac == 0) {

spec->n_grouped_frac_digits = 0;

}

else {

Py_UCS4 grouping_maxchar;

spec->n_grouped_frac_digits = _PyUnicode_InsertThousandsGrouping(

NULL, 0,

NULL, 0, spec->n_frac,

spec->n_frac,

locale->grouping, locale->frac_thousands_sep, &grouping_maxchar, 1);

if (spec->n_grouped_frac_digits == -1) {

return -1;

}

*maxchar = Py_MAX(*maxchar, grouping_maxchar);

}

/* The number of chars used for non-digits and non-padding. */

n_non_digit_non_padding = spec->n_sign + spec->n_prefix + spec->n_decimal +

+ spec->n_frac + spec->n_remainder;

/* min_width can go negative, that's okay. format->width == -1 means

we don't care. */

if (format->fill_char == '0' && format->align == '=')

spec->n_min_width = (format->width - n_non_digit_non_padding

+ spec->n_frac - spec->n_grouped_frac_digits);

else

spec->n_min_width = 0;

if (spec->n_digits == 0)

/* This case only occurs when using 'c' formatting, we need

to special case it because the grouping code always wants

to have at least one character. */

spec->n_grouped_digits = 0;

else {

Py_UCS4 grouping_maxchar;

spec->n_grouped_digits = _PyUnicode_InsertThousandsGrouping(

NULL, 0,

NULL, 0, spec->n_digits,

spec->n_min_width,

locale->grouping, locale->thousands_sep, &grouping_maxchar, 0);

if (spec->n_grouped_digits == -1) {

return -1;

}

*maxchar = Py_MAX(*maxchar, grouping_maxchar);

}

/* Given the desired width and the total of digit and non-digit

space we consume, see if we need any padding. format->width can

be negative (meaning no padding), but this code still works in

that case. */

n_padding = format->width -

(n_non_digit_non_padding + spec->n_grouped_digits

+ spec->n_grouped_frac_digits - spec->n_frac);

if (n_padding > 0) {

/* Some padding is needed. Determine if it's left, space, or right. */

switch (format->align) {

case '<':

spec->n_rpadding = n_padding;

break;

case '^':

spec->n_lpadding = n_padding / 2;

spec->n_rpadding = n_padding - spec->n_lpadding;

break;

case '=':

spec->n_spadding = n_padding;

break;

case '>':

spec->n_lpadding = n_padding;

break;

default:

/* Shouldn't get here */

Py_UNREACHABLE();

}

}

if (spec->n_lpadding || spec->n_spadding || spec->n_rpadding)

*maxchar = Py_MAX(*maxchar, format->fill_char);

if (spec->n_decimal)

*maxchar = Py_MAX(*maxchar, PyUnicode_MAX_CHAR_VALUE(locale->decimal_point));

return spec->n_lpadding + spec->n_sign + spec->n_prefix +

spec->n_spadding + spec->n_grouped_digits + spec->n_decimal +

spec->n_grouped_frac_digits + spec->n_remainder + spec->n_rpadding;

}

/* Fill in the digit parts of a number's string representation,

as determined in calc_number_widths().

Return -1 on error, or 0 on success. */

static int

fill_number(_PyUnicodeWriter *writer, const NumberFieldWidths *spec,

PyObject *digits, Py_ssize_t d_start,

PyObject *prefix, Py_ssize_t p_start,

Py_UCS4 fill_char,

LocaleInfo *locale, int toupper)

{

/* Used to keep track of digits, decimal, and remainder. */

Py_ssize_t d_pos = d_start;

const int kind = writer->kind;

const void *data = writer->data;

Py_ssize_t r;

if (spec->n_lpadding) {

_PyUnicode_FastFill(writer->buffer,

writer->pos, spec->n_lpadding, fill_char);

writer->pos += spec->n_lpadding;

}

if (spec->n_sign == 1) {

PyUnicode_WRITE(kind, data, writer->pos, spec->sign);

writer->pos++;

}

if (spec->n_prefix) {

_PyUnicode_FastCopyCharacters(writer->buffer, writer->pos,

prefix, p_start,

spec->n_prefix);

if (toupper) {

Py_ssize_t t;

for (t = 0; t < spec->n_prefix; t++) {

Py_UCS4 c = PyUnicode_READ(kind, data, writer->pos + t);

c = Py_TOUPPER(c);

assert (c <= 127);

PyUnicode_WRITE(kind, data, writer->pos + t, c);

}

}

writer->pos += spec->n_prefix;

}

if (spec->n_spadding) {

_PyUnicode_FastFill(writer->buffer,

writer->pos, spec->n_spadding, fill_char);

writer->pos += spec->n_spadding;

}

/* Only for type 'c' special case, it has no digits. */

if (spec->n_digits != 0) {

/* Fill the digits with InsertThousandsGrouping. */

r = _PyUnicode_InsertThousandsGrouping(

writer, spec->n_grouped_digits,

digits, d_pos, spec->n_digits,

spec->n_min_width,

locale->grouping, locale->thousands_sep, NULL, 0);

if (r == -1)

return -1;

assert(r == spec->n_grouped_digits);

d_pos += spec->n_digits;

}

if (toupper) {

Py_ssize_t t;

for (t = 0; t < spec->n_grouped_digits; t++) {

Py_UCS4 c = PyUnicode_READ(kind, data, writer->pos + t);

c = Py_TOUPPER(c);

if (c > 127) {

PyErr_SetString(PyExc_SystemError, "non-ascii grouped digit");

return -1;

}

PyUnicode_WRITE(kind, data, writer->pos + t, c);

}

}

writer->pos += spec->n_grouped_digits;

if (spec->n_decimal) {

_PyUnicode_FastCopyCharacters(

writer->buffer, writer->pos,

locale->decimal_point, 0, spec->n_decimal);

writer->pos += spec->n_decimal;

d_pos += 1;

}

if (spec->n_frac) {

r = _PyUnicode_InsertThousandsGrouping(

writer, spec->n_grouped_frac_digits,

digits, d_pos, spec->n_frac, spec->n_frac,

locale->grouping, locale->frac_thousands_sep, NULL, 1);

if (r == -1) {

return -1;

}

assert(r == spec->n_grouped_frac_digits);

d_pos += spec->n_frac;

writer->pos += spec->n_grouped_frac_digits;

}

if (spec->n_remainder) {

_PyUnicode_FastCopyCharacters(

writer->buffer, writer->pos,

digits, d_pos, spec->n_remainder);