Mercurial > cpython-lru_cache-weakref
annotate Python/formatter_unicode.c @ 84172:e353f64dfd95
importlib.abc.SourceLoader.get_source() was re-raising SyntaxError and
UnicodeDecodeError as ImportError. That was over-reaching the point of
raising ImportError in get_source() (which is to signal the source
code was not found when it should have). Conflating the two exceptions
with ImportError could lead to masking errors with the source which
should be known outside of whether there was an error simply getting
the source to begin with.
| author | Brett Cannon <brett@python.org> |
|---|---|
| date | Sun, 16 Jun 2013 18:05:54 -0400 |
| parents | 16a00dd78cd0 |
| children | 81fef2666ebb |
| rev | line source |
|---|---|
|
42817
5355337709e1
Implementation of PEP 3101, Advanced String Formatting.
Eric Smith <eric@trueblade.com>
parents:
diff
changeset
|
1 /* implements the unicode (as opposed to string) version of the |
|
5355337709e1
Implementation of PEP 3101, Advanced String Formatting.
Eric Smith <eric@trueblade.com>
parents:
diff
changeset
|
2 built-in formatters for string, int, float. that is, the versions |
|
5355337709e1
Implementation of PEP 3101, Advanced String Formatting.
Eric Smith <eric@trueblade.com>
parents:
diff
changeset
|
3 of int.__float__, etc., that take and return unicode objects */ |
|
5355337709e1
Implementation of PEP 3101, Advanced String Formatting.
Eric Smith <eric@trueblade.com>
parents:
diff
changeset
|
4 |
|
5355337709e1
Implementation of PEP 3101, Advanced String Formatting.
Eric Smith <eric@trueblade.com>
parents:
diff
changeset
|
5 #include "Python.h" |
| 72475 | 6 #include <locale.h> |
| 7 | |
| 8 /* Raises an exception about an unknown presentation type for this | |
| 9 * type. */ | |
| 10 | |
| 11 static void | |
| 12 unknown_presentation_type(Py_UCS4 presentation_type, | |
| 13 const char* type_name) | |
| 14 { | |
| 15 /* %c might be out-of-range, hence the two cases. */ | |
| 16 if (presentation_type > 32 && presentation_type < 128) | |
| 17 PyErr_Format(PyExc_ValueError, | |
| 18 "Unknown format code '%c' " | |
| 19 "for object of type '%.200s'", | |
| 20 (char)presentation_type, | |
| 21 type_name); | |
| 22 else | |
| 23 PyErr_Format(PyExc_ValueError, | |
| 24 "Unknown format code '\\x%x' " | |
| 25 "for object of type '%.200s'", | |
| 26 (unsigned int)presentation_type, | |
| 27 type_name); | |
| 28 } | |
| 29 | |
| 30 static void | |
| 31 invalid_comma_type(Py_UCS4 presentation_type) | |
| 32 { | |
| 33 if (presentation_type > 32 && presentation_type < 128) | |
| 34 PyErr_Format(PyExc_ValueError, | |
| 35 "Cannot specify ',' with '%c'.", | |
| 36 (char)presentation_type); | |
| 37 else | |
| 38 PyErr_Format(PyExc_ValueError, | |
| 39 "Cannot specify ',' with '\\x%x'.", | |
| 40 (unsigned int)presentation_type); | |
| 41 } | |
| 42 | |
| 43 /* | |
| 44 get_integer consumes 0 or more decimal digit characters from an | |
| 45 input string, updates *result with the corresponding positive | |
| 46 integer, and returns the number of digits consumed. | |
| 47 | |
| 48 returns -1 on error. | |
| 49 */ | |
| 50 static int | |
| 51 get_integer(PyObject *str, Py_ssize_t *pos, Py_ssize_t end, | |
| 52 Py_ssize_t *result) | |
| 53 { | |
|
73805
7e37598a25a6
Issue #9530: Fix undefined behaviour due to signed overflow in Python/formatter_unicode.c.
Mark Dickinson <mdickinson@enthought.com>
parents:
72863
diff
changeset
|
54 Py_ssize_t accumulator, digitval; |
| 72475 | 55 int numdigits; |
| 56 accumulator = numdigits = 0; | |
| 57 for (;;(*pos)++, numdigits++) { | |
| 58 if (*pos >= end) | |
| 59 break; | |
| 60 digitval = Py_UNICODE_TODECIMAL(PyUnicode_READ_CHAR(str, *pos)); | |
| 61 if (digitval < 0) | |
| 62 break; | |
| 63 /* | |
|
73805
7e37598a25a6
Issue #9530: Fix undefined behaviour due to signed overflow in Python/formatter_unicode.c.
Mark Dickinson <mdickinson@enthought.com>
parents:
72863
diff
changeset
|
64 Detect possible overflow before it happens: |
|
7e37598a25a6
Issue #9530: Fix undefined behaviour due to signed overflow in Python/formatter_unicode.c.
Mark Dickinson <mdickinson@enthought.com>
parents:
72863
diff
changeset
|
65 |
|
7e37598a25a6
Issue #9530: Fix undefined behaviour due to signed overflow in Python/formatter_unicode.c.
Mark Dickinson <mdickinson@enthought.com>
parents:
72863
diff
changeset
|
66 accumulator * 10 + digitval > PY_SSIZE_T_MAX if and only if |
|
7e37598a25a6
Issue #9530: Fix undefined behaviour due to signed overflow in Python/formatter_unicode.c.
Mark Dickinson <mdickinson@enthought.com>
parents:
72863
diff
changeset
|
67 accumulator > (PY_SSIZE_T_MAX - digitval) / 10. |
| 72475 | 68 */ |
|
73805
7e37598a25a6
Issue #9530: Fix undefined behaviour due to signed overflow in Python/formatter_unicode.c.
Mark Dickinson <mdickinson@enthought.com>
parents:
72863
diff
changeset
|
69 if (accumulator > (PY_SSIZE_T_MAX - digitval) / 10) { |
| 72475 | 70 PyErr_Format(PyExc_ValueError, |
| 71 "Too many decimal digits in format string"); | |
| 72 return -1; | |
| 73 } | |
|
73805
7e37598a25a6
Issue #9530: Fix undefined behaviour due to signed overflow in Python/formatter_unicode.c.
Mark Dickinson <mdickinson@enthought.com>
parents:
72863
diff
changeset
|
74 accumulator = accumulator * 10 + digitval; |
| 72475 | 75 } |
| 76 *result = accumulator; | |
| 77 return numdigits; | |
| 78 } | |
| 79 | |
| 80 /************************************************************************/ | |
| 81 /*********** standard format specifier parsing **************************/ | |
| 82 /************************************************************************/ | |
| 83 | |
| 84 /* returns true if this character is a specifier alignment token */ | |
| 85 Py_LOCAL_INLINE(int) | |
| 86 is_alignment_token(Py_UCS4 c) | |
| 87 { | |
| 88 switch (c) { | |
| 89 case '<': case '>': case '=': case '^': | |
| 90 return 1; | |
| 91 default: | |
| 92 return 0; | |
| 93 } | |
| 94 } | |
| 95 | |
| 96 /* returns true if this character is a sign element */ | |
| 97 Py_LOCAL_INLINE(int) | |
| 98 is_sign_element(Py_UCS4 c) | |
| 99 { | |
| 100 switch (c) { | |
| 101 case ' ': case '+': case '-': | |
| 102 return 1; | |
| 103 default: | |
| 104 return 0; | |
| 105 } | |
| 106 } | |
| 107 | |
| 108 | |
| 109 typedef struct { | |
| 110 Py_UCS4 fill_char; | |
| 111 Py_UCS4 align; | |
| 112 int alternate; | |
| 113 Py_UCS4 sign; | |
| 114 Py_ssize_t width; | |
| 115 int thousands_separators; | |
| 116 Py_ssize_t precision; | |
| 117 Py_UCS4 type; | |
| 118 } InternalFormatSpec; | |
| 119 | |
| 120 #if 0 | |
| 121 /* Occassionally useful for debugging. Should normally be commented out. */ | |
| 122 static void | |
| 123 DEBUG_PRINT_FORMAT_SPEC(InternalFormatSpec *format) | |
| 124 { | |
| 125 printf("internal format spec: fill_char %d\n", format->fill_char); | |
| 126 printf("internal format spec: align %d\n", format->align); | |
| 127 printf("internal format spec: alternate %d\n", format->alternate); | |
| 128 printf("internal format spec: sign %d\n", format->sign); | |
| 129 printf("internal format spec: width %zd\n", format->width); | |
| 130 printf("internal format spec: thousands_separators %d\n", | |
| 131 format->thousands_separators); | |
| 132 printf("internal format spec: precision %zd\n", format->precision); | |
| 133 printf("internal format spec: type %c\n", format->type); | |
| 134 printf("\n"); | |
| 135 } | |
| 136 #endif | |
| 137 | |
| 138 | |
| 139 /* | |
| 140 ptr points to the start of the format_spec, end points just past its end. | |
| 141 fills in format with the parsed information. | |
| 142 returns 1 on success, 0 on failure. | |
| 143 if failure, sets the exception | |
| 144 */ | |
| 145 static int | |
| 146 parse_internal_render_format_spec(PyObject *format_spec, | |
| 147 Py_ssize_t start, Py_ssize_t end, | |
| 148 InternalFormatSpec *format, | |
| 149 char default_type, | |
| 150 char default_align) | |
| 151 { | |
| 152 Py_ssize_t pos = start; | |
| 153 /* end-pos is used throughout this code to specify the length of | |
| 154 the input string */ | |
| 155 #define READ_spec(index) PyUnicode_READ_CHAR(format_spec, index) | |
| 156 | |
| 157 Py_ssize_t consumed; | |
| 158 int align_specified = 0; | |
| 159 | |
| 160 format->fill_char = '\0'; | |
| 161 format->align = default_align; | |
| 162 format->alternate = 0; | |
| 163 format->sign = '\0'; | |
| 164 format->width = -1; | |
| 165 format->thousands_separators = 0; | |
| 166 format->precision = -1; | |
| 167 format->type = default_type; | |
| 168 | |
| 169 /* If the second char is an alignment token, | |
| 170 then parse the fill char */ | |
| 171 if (end-pos >= 2 && is_alignment_token(READ_spec(pos+1))) { | |
| 172 format->align = READ_spec(pos+1); | |
| 173 format->fill_char = READ_spec(pos); | |
| 174 align_specified = 1; | |
| 175 pos += 2; | |
| 176 } | |
| 177 else if (end-pos >= 1 && is_alignment_token(READ_spec(pos))) { | |
| 178 format->align = READ_spec(pos); | |
| 179 align_specified = 1; | |
| 180 ++pos; | |
| 181 } | |
| 182 | |
| 183 /* Parse the various sign options */ | |
| 184 if (end-pos >= 1 && is_sign_element(READ_spec(pos))) { | |
| 185 format->sign = READ_spec(pos); | |
| 186 ++pos; | |
| 187 } | |
| 188 | |
| 189 /* If the next character is #, we're in alternate mode. This only | |
| 190 applies to integers. */ | |
| 191 if (end-pos >= 1 && READ_spec(pos) == '#') { | |
| 192 format->alternate = 1; | |
| 193 ++pos; | |
| 194 } | |
| 195 | |
| 196 /* The special case for 0-padding (backwards compat) */ | |
| 197 if (format->fill_char == '\0' && end-pos >= 1 && READ_spec(pos) == '0') { | |
| 198 format->fill_char = '0'; | |
| 199 if (!align_specified) { | |
| 200 format->align = '='; | |
| 201 } | |
| 202 ++pos; | |
| 203 } | |
| 204 | |
| 205 consumed = get_integer(format_spec, &pos, end, &format->width); | |
| 206 if (consumed == -1) | |
| 207 /* Overflow error. Exception already set. */ | |
| 208 return 0; | |
| 209 | |
| 210 /* If consumed is 0, we didn't consume any characters for the | |
| 211 width. In that case, reset the width to -1, because | |
| 212 get_integer() will have set it to zero. -1 is how we record | |
| 213 that the width wasn't specified. */ | |
| 214 if (consumed == 0) | |
| 215 format->width = -1; | |
| 216 | |
| 217 /* Comma signifies add thousands separators */ | |
| 218 if (end-pos && READ_spec(pos) == ',') { | |
| 219 format->thousands_separators = 1; | |
| 220 ++pos; | |
| 221 } | |
| 222 | |
| 223 /* Parse field precision */ | |
| 224 if (end-pos && READ_spec(pos) == '.') { | |
| 225 ++pos; | |
| 226 | |
| 227 consumed = get_integer(format_spec, &pos, end, &format->precision); | |
| 228 if (consumed == -1) | |
| 229 /* Overflow error. Exception already set. */ | |
| 230 return 0; | |
| 231 | |
| 232 /* Not having a precision after a dot is an error. */ | |
| 233 if (consumed == 0) { | |
| 234 PyErr_Format(PyExc_ValueError, | |
| 235 "Format specifier missing precision"); | |
| 236 return 0; | |
| 237 } | |
| 238 | |
| 239 } | |
| 240 | |
| 241 /* Finally, parse the type field. */ | |
| 242 | |
| 243 if (end-pos > 1) { | |
|
74533
5c33ebb50702
Improve exception text. Closes issue 13811.
Eric V. Smith <eric@trueblade.com>
parents:
74341
diff
changeset
|
244 /* More than one char remain, invalid format specifier. */ |
|
5c33ebb50702
Improve exception text. Closes issue 13811.
Eric V. Smith <eric@trueblade.com>
parents:
74341
diff
changeset
|
245 PyErr_Format(PyExc_ValueError, "Invalid format specifier"); |
| 72475 | 246 return 0; |
| 247 } | |
| 248 | |
| 249 if (end-pos == 1) { | |
| 250 format->type = READ_spec(pos); | |
| 251 ++pos; | |
| 252 } | |
| 253 | |
| 254 /* Do as much validating as we can, just by looking at the format | |
| 255 specifier. Do not take into account what type of formatting | |
| 256 we're doing (int, float, string). */ | |
| 257 | |
| 258 if (format->thousands_separators) { | |
| 259 switch (format->type) { | |
| 260 case 'd': | |
| 261 case 'e': | |
| 262 case 'f': | |
| 263 case 'g': | |
| 264 case 'E': | |
| 265 case 'G': | |
| 266 case '%': | |
| 267 case 'F': | |
| 268 case '\0': | |
| 269 /* These are allowed. See PEP 378.*/ | |
| 270 break; | |
| 271 default: | |
| 272 invalid_comma_type(format->type); | |
| 273 return 0; | |
| 274 } | |
| 275 } | |
| 276 | |
|
74557
231c6042c40c
Issue #13706: Support non-ASCII fill characters
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74533
diff
changeset
|
277 assert (format->align <= 127); |
|
231c6042c40c
Issue #13706: Support non-ASCII fill characters
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74533
diff
changeset
|
278 assert (format->sign <= 127); |
| 72475 | 279 return 1; |
| 280 } | |
| 281 | |
| 282 /* Calculate the padding needed. */ | |
| 283 static void | |
| 284 calc_padding(Py_ssize_t nchars, Py_ssize_t width, Py_UCS4 align, | |
| 285 Py_ssize_t *n_lpadding, Py_ssize_t *n_rpadding, | |
| 286 Py_ssize_t *n_total) | |
| 287 { | |
| 288 if (width >= 0) { | |
| 289 if (nchars > width) | |
| 290 *n_total = nchars; | |
| 291 else | |
| 292 *n_total = width; | |
| 293 } | |
| 294 else { | |
| 295 /* not specified, use all of the chars and no more */ | |
| 296 *n_total = nchars; | |
| 297 } | |
| 298 | |
| 299 /* Figure out how much leading space we need, based on the | |
| 300 aligning */ | |
| 301 if (align == '>') | |
| 302 *n_lpadding = *n_total - nchars; | |
| 303 else if (align == '^') | |
| 304 *n_lpadding = (*n_total - nchars) / 2; | |
| 305 else if (align == '<' || align == '=') | |
| 306 *n_lpadding = 0; | |
| 307 else { | |
| 308 /* We should never have an unspecified alignment. */ | |
| 309 *n_lpadding = 0; | |
| 310 assert(0); | |
| 311 } | |
| 312 | |
| 313 *n_rpadding = *n_total - nchars - *n_lpadding; | |
| 314 } | |
| 315 | |
| 316 /* Do the padding, and return a pointer to where the caller-supplied | |
| 317 content goes. */ | |
|
83801
16a00dd78cd0
Fix a compilater warning on Windows 64-bit
Victor Stinner <victor.stinner@gmail.com>
parents:
83675
diff
changeset
|
318 static int |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
319 fill_padding(_PyUnicodeWriter *writer, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
320 Py_ssize_t nchars, |
| 72475 | 321 Py_UCS4 fill_char, Py_ssize_t n_lpadding, |
| 322 Py_ssize_t n_rpadding) | |
| 323 { | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
324 Py_ssize_t pos; |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
325 |
| 72475 | 326 /* Pad on left. */ |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
327 if (n_lpadding) { |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
328 pos = writer->pos; |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
329 _PyUnicode_FastFill(writer->buffer, pos, n_lpadding, fill_char); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
330 } |
| 72475 | 331 |
| 332 /* Pad on right. */ | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
333 if (n_rpadding) { |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
334 pos = writer->pos + nchars + n_lpadding; |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
335 _PyUnicode_FastFill(writer->buffer, pos, n_rpadding, fill_char); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
336 } |
| 72475 | 337 |
| 338 /* Pointer to the user content. */ | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
339 writer->pos += n_lpadding; |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
340 return 0; |
| 72475 | 341 } |
| 342 | |
| 343 /************************************************************************/ | |
| 344 /*********** common routines for numeric formatting *********************/ | |
| 345 /************************************************************************/ | |
| 346 | |
| 347 /* Locale type codes. */ | |
| 348 #define LT_CURRENT_LOCALE 0 | |
| 349 #define LT_DEFAULT_LOCALE 1 | |
| 350 #define LT_NO_LOCALE 2 | |
| 351 | |
| 352 /* Locale info needed for formatting integers and the part of floats | |
| 353 before and including the decimal. Note that locales only support | |
| 354 8-bit chars, not unicode. */ | |
| 355 typedef struct { | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
356 PyObject *decimal_point; |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
357 PyObject *thousands_sep; |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
358 const char *grouping; |
| 72475 | 359 } LocaleInfo; |
| 360 | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
361 #define STATIC_LOCALE_INFO_INIT {0, 0, 0} |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
362 |
| 72475 | 363 /* describes the layout for an integer, see the comment in |
| 364 calc_number_widths() for details */ | |
| 365 typedef struct { | |
| 366 Py_ssize_t n_lpadding; | |
| 367 Py_ssize_t n_prefix; | |
| 368 Py_ssize_t n_spadding; | |
| 369 Py_ssize_t n_rpadding; | |
| 370 char sign; | |
| 371 Py_ssize_t n_sign; /* number of digits needed for sign (0/1) */ | |
| 372 Py_ssize_t n_grouped_digits; /* Space taken up by the digits, including | |
| 373 any grouping chars. */ | |
| 374 Py_ssize_t n_decimal; /* 0 if only an integer */ | |
| 375 Py_ssize_t n_remainder; /* Digits in decimal and/or exponent part, | |
| 376 excluding the decimal itself, if | |
| 377 present. */ | |
| 378 | |
| 379 /* These 2 are not the widths of fields, but are needed by | |
| 380 STRINGLIB_GROUPING. */ | |
| 381 Py_ssize_t n_digits; /* The number of digits before a decimal | |
| 382 or exponent. */ | |
| 383 Py_ssize_t n_min_width; /* The min_width we used when we computed | |
| 384 the n_grouped_digits width. */ | |
| 385 } NumberFieldWidths; | |
|
42817
5355337709e1
Implementation of PEP 3101, Advanced String Formatting.
Eric Smith <eric@trueblade.com>
parents:
diff
changeset
|
386 |
|
47393
0da27fdf0192
Refactor and clean up str.format() code (and helpers) in advance of optimizations.
Eric Smith <eric@trueblade.com>
parents:
42817
diff
changeset
|
387 |
| 72475 | 388 /* Given a number of the form: |
| 389 digits[remainder] | |
| 390 where ptr points to the start and end points to the end, find where | |
| 391 the integer part ends. This could be a decimal, an exponent, both, | |
| 392 or neither. | |
| 393 If a decimal point is present, set *has_decimal and increment | |
| 394 remainder beyond it. | |
| 395 Results are undefined (but shouldn't crash) for improperly | |
| 396 formatted strings. | |
| 397 */ | |
| 398 static void | |
| 399 parse_number(PyObject *s, Py_ssize_t pos, Py_ssize_t end, | |
| 400 Py_ssize_t *n_remainder, int *has_decimal) | |
| 401 { | |
| 402 Py_ssize_t remainder; | |
| 403 | |
|
82111
c08bcf5302ec
Issue #17173: Remove uses of locale-dependent C functions (isalpha() etc.) in the interpreter.
Antoine Pitrou <solipsis@pitrou.net>
parents:
78860
diff
changeset
|
404 while (pos<end && Py_ISDIGIT(PyUnicode_READ_CHAR(s, pos))) |
| 72475 | 405 ++pos; |
| 406 remainder = pos; | |
| 407 | |
| 408 /* Does remainder start with a decimal point? */ | |
| 409 *has_decimal = pos<end && PyUnicode_READ_CHAR(s, remainder) == '.'; | |
| 410 | |
| 411 /* Skip the decimal point. */ | |
| 412 if (*has_decimal) | |
| 413 remainder++; | |
| 414 | |
| 415 *n_remainder = end - remainder; | |
| 416 } | |
| 417 | |
| 418 /* not all fields of format are used. for example, precision is | |
| 419 unused. should this take discrete params in order to be more clear | |
| 420 about what it does? or is passing a single format parameter easier | |
| 421 and more efficient enough to justify a little obfuscation? */ | |
| 422 static Py_ssize_t | |
| 423 calc_number_widths(NumberFieldWidths *spec, Py_ssize_t n_prefix, | |
| 424 Py_UCS4 sign_char, PyObject *number, Py_ssize_t n_start, | |
| 425 Py_ssize_t n_end, Py_ssize_t n_remainder, | |
| 426 int has_decimal, const LocaleInfo *locale, | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
427 const InternalFormatSpec *format, Py_UCS4 *maxchar) |
| 72475 | 428 { |
| 429 Py_ssize_t n_non_digit_non_padding; | |
| 430 Py_ssize_t n_padding; | |
| 431 | |
| 432 spec->n_digits = n_end - n_start - n_remainder - (has_decimal?1:0); | |
| 433 spec->n_lpadding = 0; | |
| 434 spec->n_prefix = n_prefix; | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
435 spec->n_decimal = has_decimal ? PyUnicode_GET_LENGTH(locale->decimal_point) : 0; |
| 72475 | 436 spec->n_remainder = n_remainder; |
| 437 spec->n_spadding = 0; | |
| 438 spec->n_rpadding = 0; | |
| 439 spec->sign = '\0'; | |
| 440 spec->n_sign = 0; | |
| 441 | |
| 442 /* the output will look like: | |
| 443 | | | |
| 444 | <lpadding> <sign> <prefix> <spadding> <grouped_digits> <decimal> <remainder> <rpadding> | | |
| 445 | | | |
| 446 | |
| 447 sign is computed from format->sign and the actual | |
| 448 sign of the number | |
| 449 | |
| 450 prefix is given (it's for the '0x' prefix) | |
| 451 | |
| 452 digits is already known | |
| 453 | |
| 454 the total width is either given, or computed from the | |
| 455 actual digits | |
| 456 | |
| 457 only one of lpadding, spadding, and rpadding can be non-zero, | |
| 458 and it's calculated from the width and other fields | |
| 459 */ | |
| 460 | |
| 461 /* compute the various parts we're going to write */ | |
| 462 switch (format->sign) { | |
| 463 case '+': | |
| 464 /* always put a + or - */ | |
| 465 spec->n_sign = 1; | |
| 466 spec->sign = (sign_char == '-' ? '-' : '+'); | |
| 467 break; | |
| 468 case ' ': | |
| 469 spec->n_sign = 1; | |
| 470 spec->sign = (sign_char == '-' ? '-' : ' '); | |
| 471 break; | |
| 472 default: | |
| 473 /* Not specified, or the default (-) */ | |
| 474 if (sign_char == '-') { | |
| 475 spec->n_sign = 1; | |
| 476 spec->sign = '-'; | |
| 477 } | |
| 478 } | |
| 479 | |
| 480 /* The number of chars used for non-digits and non-padding. */ | |
| 481 n_non_digit_non_padding = spec->n_sign + spec->n_prefix + spec->n_decimal + | |
| 482 spec->n_remainder; | |
| 483 | |
| 484 /* min_width can go negative, that's okay. format->width == -1 means | |
| 485 we don't care. */ | |
| 486 if (format->fill_char == '0' && format->align == '=') | |
| 487 spec->n_min_width = format->width - n_non_digit_non_padding; | |
| 488 else | |
| 489 spec->n_min_width = 0; | |
| 490 | |
| 491 if (spec->n_digits == 0) | |
| 492 /* This case only occurs when using 'c' formatting, we need | |
| 493 to special case it because the grouping code always wants | |
| 494 to have at least one character. */ | |
| 495 spec->n_grouped_digits = 0; | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
496 else { |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
497 Py_UCS4 grouping_maxchar; |
| 72475 | 498 spec->n_grouped_digits = _PyUnicode_InsertThousandsGrouping( |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
499 NULL, 0, |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
500 0, NULL, |
| 72475 | 501 spec->n_digits, spec->n_min_width, |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
502 locale->grouping, locale->thousands_sep, &grouping_maxchar); |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
503 *maxchar = Py_MAX(*maxchar, grouping_maxchar); |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
504 } |
| 72475 | 505 |
| 506 /* Given the desired width and the total of digit and non-digit | |
| 507 space we consume, see if we need any padding. format->width can | |
| 508 be negative (meaning no padding), but this code still works in | |
| 509 that case. */ | |
| 510 n_padding = format->width - | |
| 511 (n_non_digit_non_padding + spec->n_grouped_digits); | |
| 512 if (n_padding > 0) { | |
| 513 /* Some padding is needed. Determine if it's left, space, or right. */ | |
| 514 switch (format->align) { | |
| 515 case '<': | |
| 516 spec->n_rpadding = n_padding; | |
| 517 break; | |
| 518 case '^': | |
| 519 spec->n_lpadding = n_padding / 2; | |
| 520 spec->n_rpadding = n_padding - spec->n_lpadding; | |
| 521 break; | |
| 522 case '=': | |
| 523 spec->n_spadding = n_padding; | |
| 524 break; | |
| 525 case '>': | |
| 526 spec->n_lpadding = n_padding; | |
| 527 break; | |
| 528 default: | |
| 529 /* Shouldn't get here, but treat it as '>' */ | |
| 530 spec->n_lpadding = n_padding; | |
| 531 assert(0); | |
| 532 break; | |
| 533 } | |
| 534 } | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
535 |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
536 if (spec->n_lpadding || spec->n_spadding || spec->n_rpadding) |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
537 *maxchar = Py_MAX(*maxchar, format->fill_char); |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
538 |
|
75234
a29d20fa85b4
Issue #13706: Fix format(float, "n") for locale with non-ASCII decimal point (e.g. ps_aF)
Victor Stinner <victor.stinner@haypocalc.com>
parents:
75231
diff
changeset
|
539 if (spec->n_decimal) |
|
a29d20fa85b4
Issue #13706: Fix format(float, "n") for locale with non-ASCII decimal point (e.g. ps_aF)
Victor Stinner <victor.stinner@haypocalc.com>
parents:
75231
diff
changeset
|
540 *maxchar = Py_MAX(*maxchar, PyUnicode_MAX_CHAR_VALUE(locale->decimal_point)); |
|
a29d20fa85b4
Issue #13706: Fix format(float, "n") for locale with non-ASCII decimal point (e.g. ps_aF)
Victor Stinner <victor.stinner@haypocalc.com>
parents:
75231
diff
changeset
|
541 |
| 72475 | 542 return spec->n_lpadding + spec->n_sign + spec->n_prefix + |
| 543 spec->n_spadding + spec->n_grouped_digits + spec->n_decimal + | |
| 544 spec->n_remainder + spec->n_rpadding; | |
| 545 } | |
| 546 | |
| 547 /* Fill in the digit parts of a numbers's string representation, | |
| 548 as determined in calc_number_widths(). | |
|
72495
cf3557b65ae1
fill_char() can now propagate an error
Victor Stinner <victor.stinner@haypocalc.com>
parents:
72475
diff
changeset
|
549 Return -1 on error, or 0 on success. */ |
|
cf3557b65ae1
fill_char() can now propagate an error
Victor Stinner <victor.stinner@haypocalc.com>
parents:
72475
diff
changeset
|
550 static int |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
551 fill_number(_PyUnicodeWriter *writer, const NumberFieldWidths *spec, |
| 72475 | 552 PyObject *digits, Py_ssize_t d_start, Py_ssize_t d_end, |
|
72495
cf3557b65ae1
fill_char() can now propagate an error
Victor Stinner <victor.stinner@haypocalc.com>
parents:
72475
diff
changeset
|
553 PyObject *prefix, Py_ssize_t p_start, |
|
cf3557b65ae1
fill_char() can now propagate an error
Victor Stinner <victor.stinner@haypocalc.com>
parents:
72475
diff
changeset
|
554 Py_UCS4 fill_char, |
| 72475 | 555 LocaleInfo *locale, int toupper) |
| 556 { | |
| 557 /* Used to keep track of digits, decimal, and remainder. */ | |
| 558 Py_ssize_t d_pos = d_start; | |
|
83675
4ce2a4e75ad3
Fix a compiler warning: use unsigned int type instead of enum PyUnicode_Kind to
Victor Stinner <victor.stinner@gmail.com>
parents:
83067
diff
changeset
|
559 const unsigned int kind = writer->kind; |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
560 const void *data = writer->data; |
| 72475 | 561 Py_ssize_t r; |
| 562 | |
| 563 if (spec->n_lpadding) { | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
564 _PyUnicode_FastFill(writer->buffer, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
565 writer->pos, spec->n_lpadding, fill_char); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
566 writer->pos += spec->n_lpadding; |
| 72475 | 567 } |
| 568 if (spec->n_sign == 1) { | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
569 PyUnicode_WRITE(kind, data, writer->pos, spec->sign); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
570 writer->pos++; |
| 72475 | 571 } |
| 572 if (spec->n_prefix) { | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
573 _PyUnicode_FastCopyCharacters(writer->buffer, writer->pos, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
574 prefix, p_start, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
575 spec->n_prefix); |
| 72475 | 576 if (toupper) { |
| 577 Py_ssize_t t; | |
|
74341
c2153ce1b5dd
remove some usage of Py_UNICODE_TOUPPER/LOWER
Benjamin Peterson <benjamin@python.org>
parents:
74261
diff
changeset
|
578 for (t = 0; t < spec->n_prefix; t++) { |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
579 Py_UCS4 c = PyUnicode_READ(kind, data, writer->pos + t); |
|
74702
056f5cc8885d
Issue #13706: Add assertions to detect bugs earlier
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74586
diff
changeset
|
580 c = Py_TOUPPER(c); |
|
74557
231c6042c40c
Issue #13706: Support non-ASCII fill characters
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74533
diff
changeset
|
581 assert (c <= 127); |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
582 PyUnicode_WRITE(kind, data, writer->pos + t, c); |
|
74341
c2153ce1b5dd
remove some usage of Py_UNICODE_TOUPPER/LOWER
Benjamin Peterson <benjamin@python.org>
parents:
74261
diff
changeset
|
583 } |
| 72475 | 584 } |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
585 writer->pos += spec->n_prefix; |
| 72475 | 586 } |
| 587 if (spec->n_spadding) { | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
588 _PyUnicode_FastFill(writer->buffer, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
589 writer->pos, spec->n_spadding, fill_char); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
590 writer->pos += spec->n_spadding; |
| 72475 | 591 } |
| 592 | |
| 593 /* Only for type 'c' special case, it has no digits. */ | |
| 594 if (spec->n_digits != 0) { | |
| 595 /* Fill the digits with InsertThousandsGrouping. */ | |
|
72496
ad337be523bf
fill_number() ensures that the 'digits' string is ready
Victor Stinner <victor.stinner@haypocalc.com>
parents:
72495
diff
changeset
|
596 char *pdigits; |
|
ad337be523bf
fill_number() ensures that the 'digits' string is ready
Victor Stinner <victor.stinner@haypocalc.com>
parents:
72495
diff
changeset
|
597 if (PyUnicode_READY(digits)) |
|
ad337be523bf
fill_number() ensures that the 'digits' string is ready
Victor Stinner <victor.stinner@haypocalc.com>
parents:
72495
diff
changeset
|
598 return -1; |
|
ad337be523bf
fill_number() ensures that the 'digits' string is ready
Victor Stinner <victor.stinner@haypocalc.com>
parents:
72495
diff
changeset
|
599 pdigits = PyUnicode_DATA(digits); |
| 72475 | 600 if (PyUnicode_KIND(digits) < kind) { |
| 601 pdigits = _PyUnicode_AsKind(digits, kind); | |
|
72495
cf3557b65ae1
fill_char() can now propagate an error
Victor Stinner <victor.stinner@haypocalc.com>
parents:
72475
diff
changeset
|
602 if (pdigits == NULL) |
|
cf3557b65ae1
fill_char() can now propagate an error
Victor Stinner <victor.stinner@haypocalc.com>
parents:
72475
diff
changeset
|
603 return -1; |
| 72475 | 604 } |
|
75234
a29d20fa85b4
Issue #13706: Fix format(float, "n") for locale with non-ASCII decimal point (e.g. ps_aF)
Victor Stinner <victor.stinner@haypocalc.com>
parents:
75231
diff
changeset
|
605 r = _PyUnicode_InsertThousandsGrouping( |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
606 writer->buffer, writer->pos, |
| 72475 | 607 spec->n_grouped_digits, |
|
72796
c25262e97304
Change PyUnicode_KIND to 1,2,4. Drop _KIND_SIZE and _CHARACTER_SIZE.
Martin v. Löwis <martin@v.loewis.de>
parents:
72714
diff
changeset
|
608 pdigits + kind * d_pos, |
| 72475 | 609 spec->n_digits, spec->n_min_width, |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
610 locale->grouping, locale->thousands_sep, NULL); |
|
75234
a29d20fa85b4
Issue #13706: Fix format(float, "n") for locale with non-ASCII decimal point (e.g. ps_aF)
Victor Stinner <victor.stinner@haypocalc.com>
parents:
75231
diff
changeset
|
611 if (r == -1) |
|
a29d20fa85b4
Issue #13706: Fix format(float, "n") for locale with non-ASCII decimal point (e.g. ps_aF)
Victor Stinner <victor.stinner@haypocalc.com>
parents:
75231
diff
changeset
|
612 return -1; |
| 72475 | 613 assert(r == spec->n_grouped_digits); |
| 614 if (PyUnicode_KIND(digits) < kind) | |
| 615 PyMem_Free(pdigits); | |
| 616 d_pos += spec->n_digits; | |
| 617 } | |
| 618 if (toupper) { | |
| 619 Py_ssize_t t; | |
|
74341
c2153ce1b5dd
remove some usage of Py_UNICODE_TOUPPER/LOWER
Benjamin Peterson <benjamin@python.org>
parents:
74261
diff
changeset
|
620 for (t = 0; t < spec->n_grouped_digits; t++) { |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
621 Py_UCS4 c = PyUnicode_READ(kind, data, writer->pos + t); |
|
74702
056f5cc8885d
Issue #13706: Add assertions to detect bugs earlier
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74586
diff
changeset
|
622 c = Py_TOUPPER(c); |
|
74341
c2153ce1b5dd
remove some usage of Py_UNICODE_TOUPPER/LOWER
Benjamin Peterson <benjamin@python.org>
parents:
74261
diff
changeset
|
623 if (c > 127) { |
|
c2153ce1b5dd
remove some usage of Py_UNICODE_TOUPPER/LOWER
Benjamin Peterson <benjamin@python.org>
parents:
74261
diff
changeset
|
624 PyErr_SetString(PyExc_SystemError, "non-ascii grouped digit"); |
|
c2153ce1b5dd
remove some usage of Py_UNICODE_TOUPPER/LOWER
Benjamin Peterson <benjamin@python.org>
parents:
74261
diff
changeset
|
625 return -1; |
|
c2153ce1b5dd
remove some usage of Py_UNICODE_TOUPPER/LOWER
Benjamin Peterson <benjamin@python.org>
parents:
74261
diff
changeset
|
626 } |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
627 PyUnicode_WRITE(kind, data, writer->pos + t, c); |
|
74341
c2153ce1b5dd
remove some usage of Py_UNICODE_TOUPPER/LOWER
Benjamin Peterson <benjamin@python.org>
parents:
74261
diff
changeset
|
628 } |
| 72475 | 629 } |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
630 writer->pos += spec->n_grouped_digits; |
| 72475 | 631 |
| 632 if (spec->n_decimal) { | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
633 _PyUnicode_FastCopyCharacters( |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
634 writer->buffer, writer->pos, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
635 locale->decimal_point, 0, spec->n_decimal); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
636 writer->pos += spec->n_decimal; |
| 72475 | 637 d_pos += 1; |
| 638 } | |
| 639 | |
| 640 if (spec->n_remainder) { | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
641 _PyUnicode_FastCopyCharacters( |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
642 writer->buffer, writer->pos, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
643 digits, d_pos, spec->n_remainder); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
644 writer->pos += spec->n_remainder; |
|
77781
85e8d2f9b33e
Comment out a dead increment.
Brett Cannon <brett@python.org>
parents:
77530
diff
changeset
|
645 /* d_pos += spec->n_remainder; */ |
| 72475 | 646 } |
| 647 | |
| 648 if (spec->n_rpadding) { | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
649 _PyUnicode_FastFill(writer->buffer, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
650 writer->pos, spec->n_rpadding, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
651 fill_char); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
652 writer->pos += spec->n_rpadding; |
| 72475 | 653 } |
|
72495
cf3557b65ae1
fill_char() can now propagate an error
Victor Stinner <victor.stinner@haypocalc.com>
parents:
72475
diff
changeset
|
654 return 0; |
| 72475 | 655 } |
| 656 | |
| 657 static char no_grouping[1] = {CHAR_MAX}; | |
| 658 | |
| 659 /* Find the decimal point character(s?), thousands_separator(s?), and | |
| 660 grouping description, either for the current locale if type is | |
| 661 LT_CURRENT_LOCALE, a hard-coded locale if LT_DEFAULT_LOCALE, or | |
| 662 none if LT_NO_LOCALE. */ | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
663 static int |
| 72475 | 664 get_locale_info(int type, LocaleInfo *locale_info) |
| 665 { | |
| 666 switch (type) { | |
| 667 case LT_CURRENT_LOCALE: { | |
| 668 struct lconv *locale_data = localeconv(); | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
669 locale_info->decimal_point = PyUnicode_DecodeLocale( |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
670 locale_data->decimal_point, |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
671 NULL); |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
672 if (locale_info->decimal_point == NULL) |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
673 return -1; |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
674 locale_info->thousands_sep = PyUnicode_DecodeLocale( |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
675 locale_data->thousands_sep, |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
676 NULL); |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
677 if (locale_info->thousands_sep == NULL) { |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
678 Py_DECREF(locale_info->decimal_point); |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
679 return -1; |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
680 } |
| 72475 | 681 locale_info->grouping = locale_data->grouping; |
| 682 break; | |
| 683 } | |
| 684 case LT_DEFAULT_LOCALE: | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
685 locale_info->decimal_point = PyUnicode_FromOrdinal('.'); |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
686 locale_info->thousands_sep = PyUnicode_FromOrdinal(','); |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
687 if (!locale_info->decimal_point || !locale_info->thousands_sep) { |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
688 Py_XDECREF(locale_info->decimal_point); |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
689 Py_XDECREF(locale_info->thousands_sep); |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
690 return -1; |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
691 } |
| 72475 | 692 locale_info->grouping = "\3"; /* Group every 3 characters. The |
| 693 (implicit) trailing 0 means repeat | |
| 694 infinitely. */ | |
| 695 break; | |
| 696 case LT_NO_LOCALE: | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
697 locale_info->decimal_point = PyUnicode_FromOrdinal('.'); |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
698 locale_info->thousands_sep = PyUnicode_New(0, 0); |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
699 if (!locale_info->decimal_point || !locale_info->thousands_sep) { |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
700 Py_XDECREF(locale_info->decimal_point); |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
701 Py_XDECREF(locale_info->thousands_sep); |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
702 return -1; |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
703 } |
| 72475 | 704 locale_info->grouping = no_grouping; |
| 705 break; | |
| 706 default: | |
| 707 assert(0); | |
| 708 } | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
709 return 0; |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
710 } |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
711 |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
712 static void |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
713 free_locale_info(LocaleInfo *locale_info) |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
714 { |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
715 Py_XDECREF(locale_info->decimal_point); |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
716 Py_XDECREF(locale_info->thousands_sep); |
| 72475 | 717 } |
| 718 | |
| 719 /************************************************************************/ | |
| 720 /*********** string formatting ******************************************/ | |
| 721 /************************************************************************/ | |
| 722 | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
723 static int |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
724 format_string_internal(PyObject *value, const InternalFormatSpec *format, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
725 _PyUnicodeWriter *writer) |
| 72475 | 726 { |
| 727 Py_ssize_t lpad; | |
| 728 Py_ssize_t rpad; | |
| 729 Py_ssize_t total; | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
730 Py_ssize_t len; |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
731 int result = -1; |
|
76509
139c3ae84772
Close #14648: Compute correctly maxchar in str.format() for substrin
Victor Stinner <victor.stinner@gmail.com>
parents:
76484
diff
changeset
|
732 Py_UCS4 maxchar; |
| 72475 | 733 |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
734 assert(PyUnicode_IS_READY(value)); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
735 len = PyUnicode_GET_LENGTH(value); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
736 |
| 72475 | 737 /* sign is not allowed on strings */ |
| 738 if (format->sign != '\0') { | |
| 739 PyErr_SetString(PyExc_ValueError, | |
| 740 "Sign not allowed in string format specifier"); | |
| 741 goto done; | |
| 742 } | |
| 743 | |
| 744 /* alternate is not allowed on strings */ | |
| 745 if (format->alternate) { | |
| 746 PyErr_SetString(PyExc_ValueError, | |
| 747 "Alternate form (#) not allowed in string format " | |
| 748 "specifier"); | |
| 749 goto done; | |
| 750 } | |
| 751 | |
| 752 /* '=' alignment not allowed on strings */ | |
| 753 if (format->align == '=') { | |
| 754 PyErr_SetString(PyExc_ValueError, | |
| 755 "'=' alignment not allowed " | |
| 756 "in string format specifier"); | |
| 757 goto done; | |
| 758 } | |
| 759 | |
|
79390
559a430e563c
Issue #15609: Optimize str%args for integer argument
Victor Stinner <victor.stinner@gmail.com>
parents:
78860
diff
changeset
|
760 if ((format->width == -1 || format->width <= len) |
|
559a430e563c
Issue #15609: Optimize str%args for integer argument
Victor Stinner <victor.stinner@gmail.com>
parents:
78860
diff
changeset
|
761 && (format->precision == -1 || format->precision >= len)) { |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
762 /* Fast path */ |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
763 return _PyUnicodeWriter_WriteStr(writer, value); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
764 } |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
765 |
| 72475 | 766 /* if precision is specified, output no more that format.precision |
| 767 characters */ | |
| 768 if (format->precision >= 0 && len >= format->precision) { | |
| 769 len = format->precision; | |
| 770 } | |
| 771 | |
| 772 calc_padding(len, format->width, format->align, &lpad, &rpad, &total); | |
| 773 | |
|
83067
7132bca093ad
Close #16757: Avoid calling the expensive _PyUnicode_FindMaxChar() function
Victor Stinner <victor.stinner@gmail.com>
parents:
82112
diff
changeset
|
774 maxchar = writer->maxchar; |
|
74557
231c6042c40c
Issue #13706: Support non-ASCII fill characters
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74533
diff
changeset
|
775 if (lpad != 0 || rpad != 0) |
|
231c6042c40c
Issue #13706: Support non-ASCII fill characters
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74533
diff
changeset
|
776 maxchar = Py_MAX(maxchar, format->fill_char); |
|
83067
7132bca093ad
Close #16757: Avoid calling the expensive _PyUnicode_FindMaxChar() function
Victor Stinner <victor.stinner@gmail.com>
parents:
82112
diff
changeset
|
777 if (PyUnicode_MAX_CHAR_VALUE(value) > maxchar) { |
|
7132bca093ad
Close #16757: Avoid calling the expensive _PyUnicode_FindMaxChar() function
Victor Stinner <victor.stinner@gmail.com>
parents:
82112
diff
changeset
|
778 Py_UCS4 valmaxchar = _PyUnicode_FindMaxChar(value, 0, len); |
|
7132bca093ad
Close #16757: Avoid calling the expensive _PyUnicode_FindMaxChar() function
Victor Stinner <victor.stinner@gmail.com>
parents:
82112
diff
changeset
|
779 maxchar = Py_MAX(maxchar, valmaxchar); |
|
7132bca093ad
Close #16757: Avoid calling the expensive _PyUnicode_FindMaxChar() function
Victor Stinner <victor.stinner@gmail.com>
parents:
82112
diff
changeset
|
780 } |
|
74557
231c6042c40c
Issue #13706: Support non-ASCII fill characters
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74533
diff
changeset
|
781 |
| 72475 | 782 /* allocate the resulting string */ |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
783 if (_PyUnicodeWriter_Prepare(writer, total, maxchar) == -1) |
| 72475 | 784 goto done; |
| 785 | |
| 786 /* Write into that space. First the padding. */ | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
787 result = fill_padding(writer, len, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
788 format->fill_char=='\0'?' ':format->fill_char, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
789 lpad, rpad); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
790 if (result == -1) |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
791 goto done; |
| 72475 | 792 |
| 793 /* Then the source string. */ | |
|
77460
00b4451bf94c
Optimize _PyUnicode_FastCopyCharacters() when maxchar(from) > maxchar(to)
Victor Stinner <victor.stinner@gmail.com>
parents:
77223
diff
changeset
|
794 if (len) { |
|
00b4451bf94c
Optimize _PyUnicode_FastCopyCharacters() when maxchar(from) > maxchar(to)
Victor Stinner <victor.stinner@gmail.com>
parents:
77223
diff
changeset
|
795 _PyUnicode_FastCopyCharacters(writer->buffer, writer->pos, |
|
00b4451bf94c
Optimize _PyUnicode_FastCopyCharacters() when maxchar(from) > maxchar(to)
Victor Stinner <victor.stinner@gmail.com>
parents:
77223
diff
changeset
|
796 value, 0, len); |
|
00b4451bf94c
Optimize _PyUnicode_FastCopyCharacters() when maxchar(from) > maxchar(to)
Victor Stinner <victor.stinner@gmail.com>
parents:
77223
diff
changeset
|
797 } |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
798 writer->pos += (len + rpad); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
799 result = 0; |
| 72475 | 800 |
| 801 done: | |
| 802 return result; | |
| 803 } | |
| 804 | |
| 805 | |
| 806 /************************************************************************/ | |
| 807 /*********** long formatting ********************************************/ | |
| 808 /************************************************************************/ | |
| 809 | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
810 static int |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
811 format_long_internal(PyObject *value, const InternalFormatSpec *format, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
812 _PyUnicodeWriter *writer) |
| 72475 | 813 { |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
814 int result = -1; |
|
74585
04b565d912c2
Fix compilation warnings (seen on win32 buildbot)
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
74557
diff
changeset
|
815 Py_UCS4 maxchar = 127; |
| 72475 | 816 PyObject *tmp = NULL; |
| 817 Py_ssize_t inumeric_chars; | |
| 818 Py_UCS4 sign_char = '\0'; | |
| 819 Py_ssize_t n_digits; /* count of digits need from the computed | |
| 820 string */ | |
| 821 Py_ssize_t n_remainder = 0; /* Used only for 'c' formatting, which | |
| 822 produces non-digits */ | |
| 823 Py_ssize_t n_prefix = 0; /* Count of prefix chars, (e.g., '0x') */ | |
| 824 Py_ssize_t n_total; | |
|
74702
056f5cc8885d
Issue #13706: Add assertions to detect bugs earlier
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74586
diff
changeset
|
825 Py_ssize_t prefix = 0; |
| 72475 | 826 NumberFieldWidths spec; |
| 827 long x; | |
| 828 | |
| 829 /* Locale settings, either from the actual locale or | |
| 830 from a hard-code pseudo-locale */ | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
831 LocaleInfo locale = STATIC_LOCALE_INFO_INIT; |
| 72475 | 832 |
| 833 /* no precision allowed on integers */ | |
| 834 if (format->precision != -1) { | |
| 835 PyErr_SetString(PyExc_ValueError, | |
| 836 "Precision not allowed in integer format specifier"); | |
| 837 goto done; | |
| 838 } | |
| 839 | |
| 840 /* special case for character formatting */ | |
| 841 if (format->type == 'c') { | |
| 842 /* error to specify a sign */ | |
| 843 if (format->sign != '\0') { | |
| 844 PyErr_SetString(PyExc_ValueError, | |
| 845 "Sign not allowed with integer" | |
| 846 " format specifier 'c'"); | |
| 847 goto done; | |
| 848 } | |
| 849 | |
| 850 /* taken from unicodeobject.c formatchar() */ | |
| 851 /* Integer input truncated to a character */ | |
| 852 x = PyLong_AsLong(value); | |
| 853 if (x == -1 && PyErr_Occurred()) | |
| 854 goto done; | |
| 855 if (x < 0 || x > 0x10ffff) { | |
| 856 PyErr_SetString(PyExc_OverflowError, | |
|
74557
231c6042c40c
Issue #13706: Support non-ASCII fill characters
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74533
diff
changeset
|
857 "%c arg not in range(0x110000)"); |
| 72475 | 858 goto done; |
| 859 } | |
| 860 tmp = PyUnicode_FromOrdinal(x); | |
| 861 inumeric_chars = 0; | |
| 862 n_digits = 1; | |
|
74586
728cfc671d15
Silence last compilation warning.
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
74585
diff
changeset
|
863 maxchar = Py_MAX(maxchar, (Py_UCS4)x); |
| 72475 | 864 |
| 865 /* As a sort-of hack, we tell calc_number_widths that we only | |
| 866 have "remainder" characters. calc_number_widths thinks | |
| 867 these are characters that don't get formatted, only copied | |
| 868 into the output string. We do this for 'c' formatting, | |
| 869 because the characters are likely to be non-digits. */ | |
| 870 n_remainder = 1; | |
| 871 } | |
| 872 else { | |
| 873 int base; | |
| 874 int leading_chars_to_skip = 0; /* Number of characters added by | |
| 875 PyNumber_ToBase that we want to | |
| 876 skip over. */ | |
| 877 | |
| 878 /* Compute the base and how many characters will be added by | |
| 879 PyNumber_ToBase */ | |
| 880 switch (format->type) { | |
| 881 case 'b': | |
| 882 base = 2; | |
| 883 leading_chars_to_skip = 2; /* 0b */ | |
| 884 break; | |
| 885 case 'o': | |
| 886 base = 8; | |
| 887 leading_chars_to_skip = 2; /* 0o */ | |
| 888 break; | |
| 889 case 'x': | |
| 890 case 'X': | |
| 891 base = 16; | |
| 892 leading_chars_to_skip = 2; /* 0x */ | |
| 893 break; | |
| 894 default: /* shouldn't be needed, but stops a compiler warning */ | |
| 895 case 'd': | |
| 896 case 'n': | |
| 897 base = 10; | |
| 898 break; | |
| 899 } | |
| 900 | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
901 if (format->sign != '+' && format->sign != ' ' |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
902 && format->width == -1 |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
903 && format->type != 'X' && format->type != 'n' |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
904 && !format->thousands_separators |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
905 && PyLong_CheckExact(value)) |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
906 { |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
907 /* Fast path */ |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
908 return _PyLong_FormatWriter(writer, value, base, format->alternate); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
909 } |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
910 |
| 72475 | 911 /* The number of prefix chars is the same as the leading |
| 912 chars to skip */ | |
| 913 if (format->alternate) | |
| 914 n_prefix = leading_chars_to_skip; | |
| 915 | |
| 916 /* Do the hard part, converting to a string in a given base */ | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
917 tmp = _PyLong_Format(value, base); |
| 72475 | 918 if (tmp == NULL || PyUnicode_READY(tmp) == -1) |
| 919 goto done; | |
| 920 | |
| 921 inumeric_chars = 0; | |
| 922 n_digits = PyUnicode_GET_LENGTH(tmp); | |
| 923 | |
| 924 prefix = inumeric_chars; | |
| 925 | |
| 926 /* Is a sign character present in the output? If so, remember it | |
| 927 and skip it */ | |
| 928 if (PyUnicode_READ_CHAR(tmp, inumeric_chars) == '-') { | |
| 929 sign_char = '-'; | |
| 930 ++prefix; | |
| 931 ++leading_chars_to_skip; | |
| 932 } | |
| 933 | |
| 934 /* Skip over the leading chars (0x, 0b, etc.) */ | |
| 935 n_digits -= leading_chars_to_skip; | |
| 936 inumeric_chars += leading_chars_to_skip; | |
| 937 } | |
| 938 | |
| 939 /* Determine the grouping, separator, and decimal point, if any. */ | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
940 if (get_locale_info(format->type == 'n' ? LT_CURRENT_LOCALE : |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
941 (format->thousands_separators ? |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
942 LT_DEFAULT_LOCALE : |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
943 LT_NO_LOCALE), |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
944 &locale) == -1) |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
945 goto done; |
| 72475 | 946 |
| 947 /* Calculate how much memory we'll need. */ | |
| 948 n_total = calc_number_widths(&spec, n_prefix, sign_char, tmp, inumeric_chars, | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
949 inumeric_chars + n_digits, n_remainder, 0, |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
950 &locale, format, &maxchar); |
|
74557
231c6042c40c
Issue #13706: Support non-ASCII fill characters
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74533
diff
changeset
|
951 |
| 72475 | 952 /* Allocate the memory. */ |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
953 if (_PyUnicodeWriter_Prepare(writer, n_total, maxchar) == -1) |
| 72475 | 954 goto done; |
| 955 | |
| 956 /* Populate the memory. */ | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
957 result = fill_number(writer, &spec, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
958 tmp, inumeric_chars, inumeric_chars + n_digits, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
959 tmp, prefix, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
960 format->fill_char == '\0' ? ' ' : format->fill_char, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
961 &locale, format->type == 'X'); |
| 72475 | 962 |
| 963 done: | |
| 964 Py_XDECREF(tmp); | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
965 free_locale_info(&locale); |
| 72475 | 966 return result; |
| 967 } | |
| 968 | |
| 969 /************************************************************************/ | |
| 970 /*********** float formatting *******************************************/ | |
| 971 /************************************************************************/ | |
| 972 | |
| 973 /* much of this is taken from unicodeobject.c */ | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
974 static int |
| 72475 | 975 format_float_internal(PyObject *value, |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
976 const InternalFormatSpec *format, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
977 _PyUnicodeWriter *writer) |
| 72475 | 978 { |
| 979 char *buf = NULL; /* buffer returned from PyOS_double_to_string */ | |
| 980 Py_ssize_t n_digits; | |
| 981 Py_ssize_t n_remainder; | |
| 982 Py_ssize_t n_total; | |
| 983 int has_decimal; | |
| 984 double val; | |
| 985 Py_ssize_t precision = format->precision; | |
| 986 Py_ssize_t default_precision = 6; | |
| 987 Py_UCS4 type = format->type; | |
| 988 int add_pct = 0; | |
| 989 Py_ssize_t index; | |
| 990 NumberFieldWidths spec; | |
| 991 int flags = 0; | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
992 int result = -1; |
|
74585
04b565d912c2
Fix compilation warnings (seen on win32 buildbot)
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
74557
diff
changeset
|
993 Py_UCS4 maxchar = 127; |
| 72475 | 994 Py_UCS4 sign_char = '\0'; |
| 995 int float_type; /* Used to see if we have a nan, inf, or regular float. */ | |
| 996 PyObject *unicode_tmp = NULL; | |
| 997 | |
| 998 /* Locale settings, either from the actual locale or | |
| 999 from a hard-code pseudo-locale */ | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1000 LocaleInfo locale = STATIC_LOCALE_INFO_INIT; |
| 72475 | 1001 |
| 1002 if (format->alternate) | |
| 1003 flags |= Py_DTSF_ALT; | |
| 1004 | |
| 1005 if (type == '\0') { | |
| 1006 /* Omitted type specifier. Behaves in the same way as repr(x) | |
| 1007 and str(x) if no precision is given, else like 'g', but with | |
| 1008 at least one digit after the decimal point. */ | |
| 1009 flags |= Py_DTSF_ADD_DOT_0; | |
| 1010 type = 'r'; | |
| 1011 default_precision = 0; | |
| 1012 } | |
| 1013 | |
| 1014 if (type == 'n') | |
| 1015 /* 'n' is the same as 'g', except for the locale used to | |
| 1016 format the result. We take care of that later. */ | |
| 1017 type = 'g'; | |
| 1018 | |
| 1019 val = PyFloat_AsDouble(value); | |
| 1020 if (val == -1.0 && PyErr_Occurred()) | |
| 1021 goto done; | |
| 1022 | |
| 1023 if (type == '%') { | |
| 1024 type = 'f'; | |
| 1025 val *= 100; | |
| 1026 add_pct = 1; | |
| 1027 } | |
| 1028 | |
| 1029 if (precision < 0) | |
| 1030 precision = default_precision; | |
| 1031 else if (type == 'r') | |
| 1032 type = 'g'; | |
| 1033 | |
| 1034 /* Cast "type", because if we're in unicode we need to pass a | |
| 1035 8-bit char. This is safe, because we've restricted what "type" | |
| 1036 can be. */ | |
| 1037 buf = PyOS_double_to_string(val, (char)type, precision, flags, | |
| 1038 &float_type); | |
| 1039 if (buf == NULL) | |
| 1040 goto done; | |
| 1041 n_digits = strlen(buf); | |
| 1042 | |
| 1043 if (add_pct) { | |
| 1044 /* We know that buf has a trailing zero (since we just called | |
| 1045 strlen() on it), and we don't use that fact any more. So we | |
| 1046 can just write over the trailing zero. */ | |
| 1047 buf[n_digits] = '%'; | |
| 1048 n_digits += 1; | |
| 1049 } | |
| 1050 | |
| 1051 /* Since there is no unicode version of PyOS_double_to_string, | |
| 1052 just use the 8 bit version and then convert to unicode. */ | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1053 unicode_tmp = _PyUnicode_FromASCII(buf, n_digits); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1054 PyMem_Free(buf); |
| 72475 | 1055 if (unicode_tmp == NULL) |
| 1056 goto done; | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1057 |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1058 if (format->sign != '+' && format->sign != ' ' |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1059 && format->width == -1 |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1060 && format->type != 'n' |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1061 && !format->thousands_separators) |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1062 { |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1063 /* Fast path */ |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1064 result = _PyUnicodeWriter_WriteStr(writer, unicode_tmp); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1065 Py_DECREF(unicode_tmp); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1066 return result; |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1067 } |
| 72475 | 1068 |
| 1069 /* Is a sign character present in the output? If so, remember it | |
| 1070 and skip it */ | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1071 index = 0; |
| 72475 | 1072 if (PyUnicode_READ_CHAR(unicode_tmp, index) == '-') { |
| 1073 sign_char = '-'; | |
| 1074 ++index; | |
| 1075 --n_digits; | |
| 1076 } | |
| 1077 | |
| 1078 /* Determine if we have any "remainder" (after the digits, might include | |
| 1079 decimal or exponent or both (or neither)) */ | |
| 1080 parse_number(unicode_tmp, index, index + n_digits, &n_remainder, &has_decimal); | |
| 1081 | |
| 1082 /* Determine the grouping, separator, and decimal point, if any. */ | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1083 if (get_locale_info(format->type == 'n' ? LT_CURRENT_LOCALE : |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1084 (format->thousands_separators ? |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1085 LT_DEFAULT_LOCALE : |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1086 LT_NO_LOCALE), |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1087 &locale) == -1) |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1088 goto done; |
| 72475 | 1089 |
| 1090 /* Calculate how much memory we'll need. */ | |
|
72495
cf3557b65ae1
fill_char() can now propagate an error
Victor Stinner <victor.stinner@haypocalc.com>
parents:
72475
diff
changeset
|
1091 n_total = calc_number_widths(&spec, 0, sign_char, unicode_tmp, index, |
| 72475 | 1092 index + n_digits, n_remainder, has_decimal, |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1093 &locale, format, &maxchar); |
|
74557
231c6042c40c
Issue #13706: Support non-ASCII fill characters
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74533
diff
changeset
|
1094 |
| 72475 | 1095 /* Allocate the memory. */ |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1096 if (_PyUnicodeWriter_Prepare(writer, n_total, maxchar) == -1) |
| 72475 | 1097 goto done; |
| 1098 | |
| 1099 /* Populate the memory. */ | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1100 result = fill_number(writer, &spec, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1101 unicode_tmp, index, index + n_digits, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1102 NULL, 0, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1103 format->fill_char == '\0' ? ' ' : format->fill_char, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1104 &locale, 0); |
| 72475 | 1105 |
| 1106 done: | |
|
78860
dc2909a62262
After the jump in line 1051 unicode_tmp is NULL. Found by Coverity.
Stefan Krah <skrah@bytereef.org>
parents:
78483
diff
changeset
|
1107 Py_XDECREF(unicode_tmp); |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1108 free_locale_info(&locale); |
| 72475 | 1109 return result; |
| 1110 } | |
| 1111 | |
| 1112 /************************************************************************/ | |
| 1113 /*********** complex formatting *****************************************/ | |
| 1114 /************************************************************************/ | |
| 1115 | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1116 static int |
| 72475 | 1117 format_complex_internal(PyObject *value, |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1118 const InternalFormatSpec *format, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1119 _PyUnicodeWriter *writer) |
| 72475 | 1120 { |
| 1121 double re; | |
| 1122 double im; | |
| 1123 char *re_buf = NULL; /* buffer returned from PyOS_double_to_string */ | |
| 1124 char *im_buf = NULL; /* buffer returned from PyOS_double_to_string */ | |
| 1125 | |
| 1126 InternalFormatSpec tmp_format = *format; | |
| 1127 Py_ssize_t n_re_digits; | |
| 1128 Py_ssize_t n_im_digits; | |
| 1129 Py_ssize_t n_re_remainder; | |
| 1130 Py_ssize_t n_im_remainder; | |
| 1131 Py_ssize_t n_re_total; | |
| 1132 Py_ssize_t n_im_total; | |
| 1133 int re_has_decimal; | |
| 1134 int im_has_decimal; | |
| 1135 Py_ssize_t precision = format->precision; | |
| 1136 Py_ssize_t default_precision = 6; | |
| 1137 Py_UCS4 type = format->type; | |
| 1138 Py_ssize_t i_re; | |
| 1139 Py_ssize_t i_im; | |
| 1140 NumberFieldWidths re_spec; | |
| 1141 NumberFieldWidths im_spec; | |
| 1142 int flags = 0; | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1143 int result = -1; |
|
74585
04b565d912c2
Fix compilation warnings (seen on win32 buildbot)
Amaury Forgeot d'Arc <amauryfa@gmail.com>
parents:
74557
diff
changeset
|
1144 Py_UCS4 maxchar = 127; |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1145 enum PyUnicode_Kind rkind; |
| 72475 | 1146 void *rdata; |
| 1147 Py_UCS4 re_sign_char = '\0'; | |
| 1148 Py_UCS4 im_sign_char = '\0'; | |
| 1149 int re_float_type; /* Used to see if we have a nan, inf, or regular float. */ | |
| 1150 int im_float_type; | |
| 1151 int add_parens = 0; | |
| 1152 int skip_re = 0; | |
| 1153 Py_ssize_t lpad; | |
| 1154 Py_ssize_t rpad; | |
| 1155 Py_ssize_t total; | |
| 1156 PyObject *re_unicode_tmp = NULL; | |
| 1157 PyObject *im_unicode_tmp = NULL; | |
| 1158 | |
| 1159 /* Locale settings, either from the actual locale or | |
| 1160 from a hard-code pseudo-locale */ | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1161 LocaleInfo locale = STATIC_LOCALE_INFO_INIT; |
| 72475 | 1162 |
| 1163 /* Zero padding is not allowed. */ | |
| 1164 if (format->fill_char == '0') { | |
| 1165 PyErr_SetString(PyExc_ValueError, | |
| 1166 "Zero padding is not allowed in complex format " | |
| 1167 "specifier"); | |
| 1168 goto done; | |
| 1169 } | |
| 1170 | |
| 1171 /* Neither is '=' alignment . */ | |
| 1172 if (format->align == '=') { | |
| 1173 PyErr_SetString(PyExc_ValueError, | |
| 1174 "'=' alignment flag is not allowed in complex format " | |
| 1175 "specifier"); | |
| 1176 goto done; | |
| 1177 } | |
| 1178 | |
| 1179 re = PyComplex_RealAsDouble(value); | |
| 1180 if (re == -1.0 && PyErr_Occurred()) | |
| 1181 goto done; | |
| 1182 im = PyComplex_ImagAsDouble(value); | |
| 1183 if (im == -1.0 && PyErr_Occurred()) | |
| 1184 goto done; | |
| 1185 | |
| 1186 if (format->alternate) | |
| 1187 flags |= Py_DTSF_ALT; | |
| 1188 | |
| 1189 if (type == '\0') { | |
| 1190 /* Omitted type specifier. Should be like str(self). */ | |
| 1191 type = 'r'; | |
| 1192 default_precision = 0; | |
| 1193 if (re == 0.0 && copysign(1.0, re) == 1.0) | |
| 1194 skip_re = 1; | |
| 1195 else | |
| 1196 add_parens = 1; | |
| 1197 } | |
| 1198 | |
| 1199 if (type == 'n') | |
| 1200 /* 'n' is the same as 'g', except for the locale used to | |
| 1201 format the result. We take care of that later. */ | |
| 1202 type = 'g'; | |
| 1203 | |
| 1204 if (precision < 0) | |
| 1205 precision = default_precision; | |
| 1206 else if (type == 'r') | |
| 1207 type = 'g'; | |
| 1208 | |
| 1209 /* Cast "type", because if we're in unicode we need to pass a | |
| 1210 8-bit char. This is safe, because we've restricted what "type" | |
| 1211 can be. */ | |
| 1212 re_buf = PyOS_double_to_string(re, (char)type, precision, flags, | |
| 1213 &re_float_type); | |
| 1214 if (re_buf == NULL) | |
| 1215 goto done; | |
| 1216 im_buf = PyOS_double_to_string(im, (char)type, precision, flags, | |
| 1217 &im_float_type); | |
| 1218 if (im_buf == NULL) | |
| 1219 goto done; | |
| 1220 | |
| 1221 n_re_digits = strlen(re_buf); | |
| 1222 n_im_digits = strlen(im_buf); | |
| 1223 | |
| 1224 /* Since there is no unicode version of PyOS_double_to_string, | |
| 1225 just use the 8 bit version and then convert to unicode. */ | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1226 re_unicode_tmp = _PyUnicode_FromASCII(re_buf, n_re_digits); |
| 72475 | 1227 if (re_unicode_tmp == NULL) |
| 1228 goto done; | |
| 1229 i_re = 0; | |
| 1230 | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1231 im_unicode_tmp = _PyUnicode_FromASCII(im_buf, n_im_digits); |
| 72475 | 1232 if (im_unicode_tmp == NULL) |
| 1233 goto done; | |
| 1234 i_im = 0; | |
| 1235 | |
| 1236 /* Is a sign character present in the output? If so, remember it | |
| 1237 and skip it */ | |
| 1238 if (PyUnicode_READ_CHAR(re_unicode_tmp, i_re) == '-') { | |
| 1239 re_sign_char = '-'; | |
| 1240 ++i_re; | |
| 1241 --n_re_digits; | |
| 1242 } | |
| 1243 if (PyUnicode_READ_CHAR(im_unicode_tmp, i_im) == '-') { | |
| 1244 im_sign_char = '-'; | |
| 1245 ++i_im; | |
| 1246 --n_im_digits; | |
| 1247 } | |
| 1248 | |
| 1249 /* Determine if we have any "remainder" (after the digits, might include | |
| 1250 decimal or exponent or both (or neither)) */ | |
|
72495
cf3557b65ae1
fill_char() can now propagate an error
Victor Stinner <victor.stinner@haypocalc.com>
parents:
72475
diff
changeset
|
1251 parse_number(re_unicode_tmp, i_re, i_re + n_re_digits, |
| 72475 | 1252 &n_re_remainder, &re_has_decimal); |
|
72495
cf3557b65ae1
fill_char() can now propagate an error
Victor Stinner <victor.stinner@haypocalc.com>
parents:
72475
diff
changeset
|
1253 parse_number(im_unicode_tmp, i_im, i_im + n_im_digits, |
| 72475 | 1254 &n_im_remainder, &im_has_decimal); |
| 1255 | |
| 1256 /* Determine the grouping, separator, and decimal point, if any. */ | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1257 if (get_locale_info(format->type == 'n' ? LT_CURRENT_LOCALE : |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1258 (format->thousands_separators ? |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1259 LT_DEFAULT_LOCALE : |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1260 LT_NO_LOCALE), |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1261 &locale) == -1) |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1262 goto done; |
| 72475 | 1263 |
| 1264 /* Turn off any padding. We'll do it later after we've composed | |
| 1265 the numbers without padding. */ | |
| 1266 tmp_format.fill_char = '\0'; | |
| 1267 tmp_format.align = '<'; | |
| 1268 tmp_format.width = -1; | |
| 1269 | |
| 1270 /* Calculate how much memory we'll need. */ | |
| 1271 n_re_total = calc_number_widths(&re_spec, 0, re_sign_char, re_unicode_tmp, | |
| 1272 i_re, i_re + n_re_digits, n_re_remainder, | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1273 re_has_decimal, &locale, &tmp_format, |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1274 &maxchar); |
| 72475 | 1275 |
| 1276 /* Same formatting, but always include a sign, unless the real part is | |
| 1277 * going to be omitted, in which case we use whatever sign convention was | |
| 1278 * requested by the original format. */ | |
| 1279 if (!skip_re) | |
| 1280 tmp_format.sign = '+'; | |
| 1281 n_im_total = calc_number_widths(&im_spec, 0, im_sign_char, im_unicode_tmp, | |
| 1282 i_im, i_im + n_im_digits, n_im_remainder, | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1283 im_has_decimal, &locale, &tmp_format, |
|
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1284 &maxchar); |
| 72475 | 1285 |
| 1286 if (skip_re) | |
| 1287 n_re_total = 0; | |
| 1288 | |
| 1289 /* Add 1 for the 'j', and optionally 2 for parens. */ | |
| 1290 calc_padding(n_re_total + n_im_total + 1 + add_parens * 2, | |
| 1291 format->width, format->align, &lpad, &rpad, &total); | |
| 1292 | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1293 if (lpad || rpad) |
|
74557
231c6042c40c
Issue #13706: Support non-ASCII fill characters
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74533
diff
changeset
|
1294 maxchar = Py_MAX(maxchar, format->fill_char); |
|
231c6042c40c
Issue #13706: Support non-ASCII fill characters
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74533
diff
changeset
|
1295 |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1296 if (_PyUnicodeWriter_Prepare(writer, total, maxchar) == -1) |
| 72475 | 1297 goto done; |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1298 rkind = writer->kind; |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1299 rdata = writer->data; |
| 72475 | 1300 |
| 1301 /* Populate the memory. First, the padding. */ | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1302 result = fill_padding(writer, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1303 n_re_total + n_im_total + 1 + add_parens * 2, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1304 format->fill_char=='\0' ? ' ' : format->fill_char, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1305 lpad, rpad); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1306 if (result == -1) |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1307 goto done; |
| 72475 | 1308 |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1309 if (add_parens) { |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1310 PyUnicode_WRITE(rkind, rdata, writer->pos, '('); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1311 writer->pos++; |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1312 } |
| 72475 | 1313 |
| 1314 if (!skip_re) { | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1315 result = fill_number(writer, &re_spec, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1316 re_unicode_tmp, i_re, i_re + n_re_digits, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1317 NULL, 0, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1318 0, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1319 &locale, 0); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1320 if (result == -1) |
|
72495
cf3557b65ae1
fill_char() can now propagate an error
Victor Stinner <victor.stinner@haypocalc.com>
parents:
72475
diff
changeset
|
1321 goto done; |
| 72475 | 1322 } |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1323 result = fill_number(writer, &im_spec, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1324 im_unicode_tmp, i_im, i_im + n_im_digits, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1325 NULL, 0, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1326 0, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1327 &locale, 0); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1328 if (result == -1) |
|
72495
cf3557b65ae1
fill_char() can now propagate an error
Victor Stinner <victor.stinner@haypocalc.com>
parents:
72475
diff
changeset
|
1329 goto done; |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1330 PyUnicode_WRITE(rkind, rdata, writer->pos, 'j'); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1331 writer->pos++; |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1332 |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1333 if (add_parens) { |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1334 PyUnicode_WRITE(rkind, rdata, writer->pos, ')'); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1335 writer->pos++; |
|
72495
cf3557b65ae1
fill_char() can now propagate an error
Victor Stinner <victor.stinner@haypocalc.com>
parents:
72475
diff
changeset
|
1336 } |
| 72475 | 1337 |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1338 writer->pos += rpad; |
| 72475 | 1339 |
| 1340 done: | |
| 1341 PyMem_Free(re_buf); | |
| 1342 PyMem_Free(im_buf); | |
| 1343 Py_XDECREF(re_unicode_tmp); | |
| 1344 Py_XDECREF(im_unicode_tmp); | |
|
75231
f89e2f4cda88
Issue #13706: Fix format(int, "n") for locale with non-ASCII thousands separator
Victor Stinner <victor.stinner@haypocalc.com>
parents:
74702
diff
changeset
|
1345 free_locale_info(&locale); |
| 72475 | 1346 return result; |
| 1347 } | |
| 1348 | |
| 1349 /************************************************************************/ | |
| 1350 /*********** built in formatters ****************************************/ | |
| 1351 /************************************************************************/ | |
| 77530 | 1352 static int |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1353 format_obj(PyObject *obj, _PyUnicodeWriter *writer) |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1354 { |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1355 PyObject *str; |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1356 int err; |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1357 |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1358 str = PyObject_Str(obj); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1359 if (str == NULL) |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1360 return -1; |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1361 err = _PyUnicodeWriter_WriteStr(writer, str); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1362 Py_DECREF(str); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1363 return err; |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1364 } |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1365 |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1366 int |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1367 _PyUnicode_FormatAdvancedWriter(_PyUnicodeWriter *writer, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1368 PyObject *obj, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1369 PyObject *format_spec, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1370 Py_ssize_t start, Py_ssize_t end) |
| 72475 | 1371 { |
| 1372 InternalFormatSpec format; | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1373 |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1374 assert(PyUnicode_Check(obj)); |
| 72475 | 1375 |
| 1376 /* check for the special case of zero length format spec, make | |
| 1377 it equivalent to str(obj) */ | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1378 if (start == end) { |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1379 if (PyUnicode_CheckExact(obj)) |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1380 return _PyUnicodeWriter_WriteStr(writer, obj); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1381 else |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1382 return format_obj(obj, writer); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1383 } |
| 72475 | 1384 |
| 1385 /* parse the format_spec */ | |
| 1386 if (!parse_internal_render_format_spec(format_spec, start, end, | |
| 1387 &format, 's', '<')) | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1388 return -1; |
| 72475 | 1389 |
| 1390 /* type conversion? */ | |
| 1391 switch (format.type) { | |
| 1392 case 's': | |
| 1393 /* no type conversion needed, already a string. do the formatting */ | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1394 return format_string_internal(obj, &format, writer); |
| 72475 | 1395 default: |
| 1396 /* unknown */ | |
| 1397 unknown_presentation_type(format.type, obj->ob_type->tp_name); | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1398 return -1; |
| 72475 | 1399 } |
| 1400 } | |
| 1401 | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1402 int |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1403 _PyLong_FormatAdvancedWriter(_PyUnicodeWriter *writer, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1404 PyObject *obj, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1405 PyObject *format_spec, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1406 Py_ssize_t start, Py_ssize_t end) |
| 72475 | 1407 { |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1408 PyObject *tmp = NULL, *str = NULL; |
| 72475 | 1409 InternalFormatSpec format; |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1410 int result = -1; |
| 72475 | 1411 |
| 1412 /* check for the special case of zero length format spec, make | |
| 1413 it equivalent to str(obj) */ | |
| 1414 if (start == end) { | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1415 if (PyLong_CheckExact(obj)) |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1416 return _PyLong_FormatWriter(writer, obj, 10, 0); |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1417 else |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1418 return format_obj(obj, writer); |
| 72475 | 1419 } |
| 1420 | |
| 1421 /* parse the format_spec */ | |
| 1422 if (!parse_internal_render_format_spec(format_spec, start, end, | |
| 1423 &format, 'd', '>')) | |
| 1424 goto done; | |
| 1425 | |
| 1426 /* type conversion? */ | |
| 1427 switch (format.type) { | |
| 1428 case 'b': | |
| 1429 case 'c': | |
| 1430 case 'd': | |
| 1431 case 'o': | |
| 1432 case 'x': | |
| 1433 case 'X': | |
| 1434 case 'n': | |
| 1435 /* no type conversion needed, already an int (or long). do | |
| 1436 the formatting */ | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1437 result = format_long_internal(obj, &format, writer); |
| 72475 | 1438 break; |
| 1439 | |
| 1440 case 'e': | |
| 1441 case 'E': | |
| 1442 case 'f': | |
| 1443 case 'F': | |
| 1444 case 'g': | |
| 1445 case 'G': | |
| 1446 case '%': | |
| 1447 /* convert to float */ | |
| 1448 tmp = PyNumber_Float(obj); | |
| 1449 if (tmp == NULL) | |
| 1450 goto done; | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1451 result = format_float_internal(tmp, &format, writer); |
| 72475 | 1452 break; |
| 1453 | |
| 1454 default: | |
| 1455 /* unknown */ | |
| 1456 unknown_presentation_type(format.type, obj->ob_type->tp_name); | |
| 1457 goto done; | |
| 1458 } | |
| 1459 | |
| 1460 done: | |
| 1461 Py_XDECREF(tmp); | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1462 Py_XDECREF(str); |
| 72475 | 1463 return result; |
| 1464 } | |
| 1465 | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1466 int |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1467 _PyFloat_FormatAdvancedWriter(_PyUnicodeWriter *writer, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1468 PyObject *obj, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1469 PyObject *format_spec, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1470 Py_ssize_t start, Py_ssize_t end) |
| 72475 | 1471 { |
| 1472 InternalFormatSpec format; | |
| 1473 | |
| 1474 /* check for the special case of zero length format spec, make | |
| 1475 it equivalent to str(obj) */ | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1476 if (start == end) |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1477 return format_obj(obj, writer); |
| 72475 | 1478 |
| 1479 /* parse the format_spec */ | |
| 1480 if (!parse_internal_render_format_spec(format_spec, start, end, | |
| 1481 &format, '\0', '>')) | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1482 return -1; |
| 72475 | 1483 |
| 1484 /* type conversion? */ | |
| 1485 switch (format.type) { | |
| 1486 case '\0': /* No format code: like 'g', but with at least one decimal. */ | |
| 1487 case 'e': | |
| 1488 case 'E': | |
| 1489 case 'f': | |
| 1490 case 'F': | |
| 1491 case 'g': | |
| 1492 case 'G': | |
| 1493 case 'n': | |
| 1494 case '%': | |
| 1495 /* no conversion, already a float. do the formatting */ | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1496 return format_float_internal(obj, &format, writer); |
| 72475 | 1497 |
| 1498 default: | |
| 1499 /* unknown */ | |
| 1500 unknown_presentation_type(format.type, obj->ob_type->tp_name); | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1501 return -1; |
| 72475 | 1502 } |
| 1503 } | |
| 1504 | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1505 int |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1506 _PyComplex_FormatAdvancedWriter(_PyUnicodeWriter *writer, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1507 PyObject *obj, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1508 PyObject *format_spec, |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1509 Py_ssize_t start, Py_ssize_t end) |
| 72475 | 1510 { |
| 1511 InternalFormatSpec format; | |
| 1512 | |
| 1513 /* check for the special case of zero length format spec, make | |
| 1514 it equivalent to str(obj) */ | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1515 if (start == end) |
|
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1516 return format_obj(obj, writer); |
| 72475 | 1517 |
| 1518 /* parse the format_spec */ | |
| 1519 if (!parse_internal_render_format_spec(format_spec, start, end, | |
| 1520 &format, '\0', '>')) | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1521 return -1; |
| 72475 | 1522 |
| 1523 /* type conversion? */ | |
| 1524 switch (format.type) { | |
| 1525 case '\0': /* No format code: like 'g', but with at least one decimal. */ | |
| 1526 case 'e': | |
| 1527 case 'E': | |
| 1528 case 'f': | |
| 1529 case 'F': | |
| 1530 case 'g': | |
| 1531 case 'G': | |
| 1532 case 'n': | |
| 1533 /* no conversion, already a complex. do the formatting */ | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1534 return format_complex_internal(obj, &format, writer); |
| 72475 | 1535 |
| 1536 default: | |
| 1537 /* unknown */ | |
| 1538 unknown_presentation_type(format.type, obj->ob_type->tp_name); | |
|
77223
22b56b0b8619
Issue #14744: Use the new _PyUnicodeWriter internal API to speed up str%args and str.format(args)
Victor Stinner <victor.stinner@gmail.com>
parents:
76509
diff
changeset
|
1539 return -1; |
| 72475 | 1540 } |
| 1541 } |