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

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 '_'.");

}

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;

/*

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;

}

Py_LOCAL_INLINE(int)

is_alignment_token(Py_UCS4 c)

{

switch (c) {

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

return 1;

default:

return 0;

}

}

Py_LOCAL_INLINE(int)

is_sign_element(Py_UCS4 c)

{

switch (c) {

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

return 1;

default:

return 0;

}

}

enum LocaleType {

};

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;

static int

parse_internal_render_format_spec(PyObject *obj,

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

#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,

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.

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

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

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

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

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

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

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;

}

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

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;

}

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;

}

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}

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

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

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

Py_ssize_t n_frac;

Py_ssize_t n_grouped_frac_digits;

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

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

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

} NumberFieldWidths;

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;

}

static Py_ssize_t

calc_number_widths(NumberFieldWidths *spec, Py_ssize_t n_prefix,

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:

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

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

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

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;

}

static int

fill_number(_PyUnicodeWriter *writer, const NumberFieldWidths *spec,

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

writer->pos += spec->n_remainder;

/* d_pos += spec->n_remainder; */

}

if (spec->n_rpadding) {

_PyUnicode_FastFill(writer->buffer,

writer->pos, spec->n_rpadding,

fill_char);

writer->pos += spec->n_rpadding;

}

return 0;

}

static const char no_grouping[1] = {CHAR_MAX};

static int

get_locale_info(enum LocaleType type, enum LocaleType frac_type,

LocaleInfo *locale_info)

{

switch (type) {

case LT_CURRENT_LOCALE: {

struct lconv *lc = localeconv();

if (_Py_GetLocaleconvNumeric(lc,

&locale_info->decimal_point,

&locale_info->thousands_sep) < 0) {

return -1;

}

/* localeconv() grouping can become a dangling pointer or point

locale_info->grouping_buffer = _PyMem_Strdup(lc->grouping);

if (locale_info->grouping_buffer == NULL) {

PyErr_NoMemory();

return -1;

}

locale_info->grouping = locale_info->grouping_buffer;

break;

}

case LT_DEFAULT_LOCALE:

case LT_UNDERSCORE_LOCALE:

case LT_UNDER_FOUR_LOCALE:

locale_info->decimal_point = PyUnicode_FromOrdinal('.');

locale_info->thousands_sep = PyUnicode_FromOrdinal(

type == LT_DEFAULT_LOCALE ? ',' : '_');

if (!locale_info->decimal_point || !locale_info->thousands_sep)

return -1;

if (type != LT_UNDER_FOUR_LOCALE)

locale_info->grouping = "\3"; /* Group every 3 characters. The

else

locale_info->grouping = "\4"; /* Bin/oct/hex group every four. */

break;

case LT_NO_LOCALE:

locale_info->decimal_point = PyUnicode_FromOrdinal('.');

locale_info->thousands_sep = Py_GetConstant(Py_CONSTANT_EMPTY_STR);

if (!locale_info->decimal_point || !locale_info->thousands_sep)

return -1;

locale_info->grouping = no_grouping;

break;

}

if (frac_type != LT_NO_LOCALE) {

locale_info->frac_thousands_sep = PyUnicode_FromOrdinal(

frac_type == LT_DEFAULT_LOCALE ? ',' : '_');

if (!locale_info->frac_thousands_sep) {

return -1;

}

if (locale_info->grouping == no_grouping) {

locale_info->grouping = "\3";

}

}

else {

locale_info->frac_thousands_sep = Py_GetConstant(Py_CONSTANT_EMPTY_STR);

}

return 0;

}

static void

free_locale_info(LocaleInfo *locale_info)

{

Py_XDECREF(locale_info->decimal_point);

Py_XDECREF(locale_info->thousands_sep);

Py_XDECREF(locale_info->frac_thousands_sep);

PyMem_Free(locale_info->grouping_buffer);

}

static int

format_string_internal(PyObject *value, const InternalFormatSpec *format,

_PyUnicodeWriter *writer)

{

Py_ssize_t lpad;

Py_ssize_t rpad;

Py_ssize_t total;

Py_ssize_t len;

int result = -1;

Py_UCS4 maxchar;

len = PyUnicode_GET_LENGTH(value);

/* sign is not allowed on strings */

if (format->sign != '\0') {

if (format->sign == ' ') {

PyErr_SetString(PyExc_ValueError,

"Space not allowed in string format specifier");

}

else {

PyErr_SetString(PyExc_ValueError,

"Sign not allowed in string format specifier");

}

goto done;

}

/* negative 0 coercion is not allowed on strings */

if (format->no_neg_0) {

PyErr_SetString(PyExc_ValueError,

"Negative zero coercion (z) not allowed in string format "

"specifier");

goto done;

}

/* alternate is not allowed on strings */

if (format->alternate) {

PyErr_SetString(PyExc_ValueError,

"Alternate form (#) not allowed in string format "

"specifier");

goto done;

}

/* '=' alignment not allowed on strings */

if (format->align == '=') {

PyErr_SetString(PyExc_ValueError,

"'=' alignment not allowed "

"in string format specifier");

goto done;

}

if ((format->width == -1 || format->width <= len)

&& (format->precision == -1 || format->precision >= len)) {

/* Fast path */

return _PyUnicodeWriter_WriteStr(writer, value);

}

/* if precision is specified, output no more that format.precision

if (format->precision >= 0 && len >= format->precision) {

len = format->precision;

}

calc_padding(len, format->width, format->align, &lpad, &rpad, &total);

maxchar = writer->maxchar;

if (lpad != 0 || rpad != 0)

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

if (PyUnicode_MAX_CHAR_VALUE(value) > maxchar) {

Py_UCS4 valmaxchar = _PyUnicode_FindMaxChar(value, 0, len);

maxchar = Py_MAX(maxchar, valmaxchar);

}

/* allocate the resulting string */

if (_PyUnicodeWriter_Prepare(writer, total, maxchar) == -1)

goto done;

/* Write into that space. First the padding. */

result = fill_padding(writer, len, format->fill_char, lpad, rpad);

if (result == -1)

goto done;

/* Then the source string. */

if (len) {

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

value, 0, len);

}

writer->pos += (len + rpad);

result = 0;

done:

return result;

}

static int

format_long_internal(PyObject *value, const InternalFormatSpec *format,

_PyUnicodeWriter *writer)

{

int result = -1;

Py_UCS4 maxchar = 127;

PyObject *tmp = NULL;

Py_ssize_t inumeric_chars;

Py_UCS4 sign_char = '\0';

Py_ssize_t n_digits; /* count of digits need from the computed

Py_ssize_t n_remainder = 0; /* Used only for 'c' formatting, which

Py_ssize_t n_prefix = 0; /* Count of prefix chars, (e.g., '0x') */

Py_ssize_t n_total;

Py_ssize_t prefix = 0;

NumberFieldWidths spec;

long x;

/* Locale settings, either from the actual locale or

LocaleInfo locale = LocaleInfo_STATIC_INIT;

/* no precision allowed on integers */

if (format->precision != -1) {

PyErr_SetString(PyExc_ValueError,

"Precision not allowed in integer format specifier");

goto done;

}

/* no negative zero coercion on integers */

if (format->no_neg_0) {

PyErr_SetString(PyExc_ValueError,

"Negative zero coercion (z) not allowed in integer"

" format specifier");

goto done;

}

/* special case for character formatting */

if (format->type == 'c') {

/* error to specify a sign */

if (format->sign != '\0') {

PyErr_SetString(PyExc_ValueError,