Changeset 391 for python/trunk/Objects/stringlib/formatter.h
- Timestamp:
- Mar 19, 2014, 11:31:01 PM (11 years ago)
- Location:
- python/trunk
- Files:
-
- 2 edited
Legend:
- Unmodified
- Added
- Removed
-
python/trunk
-
Property svn:mergeinfo
set to
/python/vendor/Python-2.7.6 merged eligible /python/vendor/current merged eligible
-
Property svn:mergeinfo
set to
-
python/trunk/Objects/stringlib/formatter.h
r2 r391 1 1 /* implements the string, long, and float formatters. that is, 2 2 string.__format__, etc. */ 3 4 #include <locale.h> 3 5 4 6 /* Before including this, you must include either: … … 10 12 FORMAT_LONG 11 13 FORMAT_FLOAT 14 FORMAT_COMPLEX 12 15 to be whatever you want the public names of these functions to 13 16 be. These are the only non-static functions defined here. 14 17 */ 15 16 #define ALLOW_PARENS_FOR_SIGN 017 18 18 19 /* Raises an exception about an unknown presentation type for this … … 44 45 } 45 46 47 static void 48 invalid_comma_type(STRINGLIB_CHAR presentation_type) 49 { 50 #if STRINGLIB_IS_UNICODE 51 /* See comment in unknown_presentation_type */ 52 if (presentation_type > 32 && presentation_type < 128) 53 #endif 54 PyErr_Format(PyExc_ValueError, 55 "Cannot specify ',' with '%c'.", 56 (char)presentation_type); 57 #if STRINGLIB_IS_UNICODE 58 else 59 PyErr_Format(PyExc_ValueError, 60 "Cannot specify ',' with '\\x%x'.", 61 (unsigned int)presentation_type); 62 #endif 63 } 64 46 65 /* 47 66 get_integer consumes 0 or more decimal digit characters from an … … 55 74 Py_ssize_t *result) 56 75 { 57 Py_ssize_t accumulator, digitval , oldaccumulator;76 Py_ssize_t accumulator, digitval; 58 77 int numdigits; 59 78 accumulator = numdigits = 0; … … 65 84 break; 66 85 /* 67 This trick was copied from old Unicode format code. It's cute,68 but would really suck on an old machine with a slow divide 69 implementation. Fortunately, in the normal case we do not70 expect too many digits.86 Detect possible overflow before it happens: 87 88 accumulator * 10 + digitval > PY_SSIZE_T_MAX if and only if 89 accumulator > (PY_SSIZE_T_MAX - digitval) / 10. 71 90 */ 72 oldaccumulator = accumulator; 73 accumulator *= 10; 74 if ((accumulator+10)/10 != oldaccumulator+1) { 91 if (accumulator > (PY_SSIZE_T_MAX - digitval) / 10) { 75 92 PyErr_Format(PyExc_ValueError, 76 93 "Too many decimal digits in format string"); 77 94 return -1; 78 95 } 79 accumulator +=digitval;96 accumulator = accumulator * 10 + digitval; 80 97 } 81 98 *result = accumulator; … … 105 122 switch (c) { 106 123 case ' ': case '+': case '-': 107 #if ALLOW_PARENS_FOR_SIGN108 case '(':109 #endif110 124 return 1; 111 125 default: … … 121 135 STRINGLIB_CHAR sign; 122 136 Py_ssize_t width; 137 int thousands_separators; 123 138 Py_ssize_t precision; 124 139 STRINGLIB_CHAR type; 125 140 } InternalFormatSpec; 141 142 143 #if 0 144 /* Occassionally useful for debugging. Should normally be commented out. */ 145 static void 146 DEBUG_PRINT_FORMAT_SPEC(InternalFormatSpec *format) 147 { 148 printf("internal format spec: fill_char %d\n", format->fill_char); 149 printf("internal format spec: align %d\n", format->align); 150 printf("internal format spec: alternate %d\n", format->alternate); 151 printf("internal format spec: sign %d\n", format->sign); 152 printf("internal format spec: width %zd\n", format->width); 153 printf("internal format spec: thousands_separators %d\n", 154 format->thousands_separators); 155 printf("internal format spec: precision %zd\n", format->precision); 156 printf("internal format spec: type %c\n", format->type); 157 printf("\n"); 158 } 159 #endif 160 126 161 127 162 /* … … 133 168 static int 134 169 parse_internal_render_format_spec(STRINGLIB_CHAR *format_spec, 135 170 Py_ssize_t format_spec_len, 136 171 InternalFormatSpec *format, 137 char default_type) 172 char default_type, 173 char default_align) 138 174 { 139 175 STRINGLIB_CHAR *ptr = format_spec; … … 143 179 the input string */ 144 180 145 Py_ssize_t specified_width; 181 Py_ssize_t consumed; 182 int align_specified = 0; 146 183 147 184 format->fill_char = '\0'; 148 format->align = '\0';185 format->align = default_align; 149 186 format->alternate = 0; 150 187 format->sign = '\0'; 151 188 format->width = -1; 189 format->thousands_separators = 0; 152 190 format->precision = -1; 153 191 format->type = default_type; … … 158 196 format->align = ptr[1]; 159 197 format->fill_char = ptr[0]; 198 align_specified = 1; 160 199 ptr += 2; 161 200 } 162 201 else if (end-ptr >= 1 && is_alignment_token(ptr[0])) { 163 202 format->align = ptr[0]; 203 align_specified = 1; 164 204 ++ptr; 165 205 } … … 169 209 format->sign = ptr[0]; 170 210 ++ptr; 171 #if ALLOW_PARENS_FOR_SIGN172 if (end-ptr >= 1 && ptr[0] == ')') {173 ++ptr;174 }175 #endif176 211 } 177 212 … … 179 214 applies to integers. */ 180 215 if (end-ptr >= 1 && ptr[0] == '#') { 181 182 216 format->alternate = 1; 217 ++ptr; 183 218 } 184 219 … … 186 221 if (format->fill_char == '\0' && end-ptr >= 1 && ptr[0] == '0') { 187 222 format->fill_char = '0'; 188 if ( format->align == '\0') {223 if (!align_specified) { 189 224 format->align = '='; 190 225 } … … 192 227 } 193 228 194 /* XXX add error checking */ 195 specified_width = get_integer(&ptr, end, &format->width); 196 197 /* if specified_width is 0, we didn't consume any characters for 198 the width. in that case, reset the width to -1, because 199 get_integer() will have set it to zero */ 200 if (specified_width == 0) { 229 consumed = get_integer(&ptr, end, &format->width); 230 if (consumed == -1) 231 /* Overflow error. Exception already set. */ 232 return 0; 233 234 /* If consumed is 0, we didn't consume any characters for the 235 width. In that case, reset the width to -1, because 236 get_integer() will have set it to zero. -1 is how we record 237 that the width wasn't specified. */ 238 if (consumed == 0) 201 239 format->width = -1; 240 241 /* Comma signifies add thousands separators */ 242 if (end-ptr && ptr[0] == ',') { 243 format->thousands_separators = 1; 244 ++ptr; 202 245 } 203 246 … … 206 249 ++ptr; 207 250 208 /* XXX add error checking */ 209 specified_width = get_integer(&ptr, end, &format->precision); 210 211 /* not having a precision after a dot is an error */ 212 if (specified_width == 0) { 251 consumed = get_integer(&ptr, end, &format->precision); 252 if (consumed == -1) 253 /* Overflow error. Exception already set. */ 254 return 0; 255 256 /* Not having a precision after a dot is an error. */ 257 if (consumed == 0) { 213 258 PyErr_Format(PyExc_ValueError, 214 259 "Format specifier missing precision"); … … 218 263 } 219 264 220 /* Finally, parse the type field */265 /* Finally, parse the type field. */ 221 266 222 267 if (end-ptr > 1) { 223 /* invalid conversion spec*/268 /* More than one char remain, invalid conversion spec. */ 224 269 PyErr_Format(PyExc_ValueError, "Invalid conversion specification"); 225 270 return 0; … … 231 276 } 232 277 278 /* Do as much validating as we can, just by looking at the format 279 specifier. Do not take into account what type of formatting 280 we're doing (int, float, string). */ 281 282 if (format->thousands_separators) { 283 switch (format->type) { 284 case 'd': 285 case 'e': 286 case 'f': 287 case 'g': 288 case 'E': 289 case 'G': 290 case '%': 291 case 'F': 292 case '\0': 293 /* These are allowed. See PEP 378.*/ 294 break; 295 default: 296 invalid_comma_type(format->type); 297 return 0; 298 } 299 } 300 233 301 return 1; 234 302 } 235 303 236 #if defined FORMAT_FLOAT || defined FORMAT_LONG 304 /* Calculate the padding needed. */ 305 static void 306 calc_padding(Py_ssize_t nchars, Py_ssize_t width, STRINGLIB_CHAR align, 307 Py_ssize_t *n_lpadding, Py_ssize_t *n_rpadding, 308 Py_ssize_t *n_total) 309 { 310 if (width >= 0) { 311 if (nchars > width) 312 *n_total = nchars; 313 else 314 *n_total = width; 315 } 316 else { 317 /* not specified, use all of the chars and no more */ 318 *n_total = nchars; 319 } 320 321 /* Figure out how much leading space we need, based on the 322 aligning */ 323 if (align == '>') 324 *n_lpadding = *n_total - nchars; 325 else if (align == '^') 326 *n_lpadding = (*n_total - nchars) / 2; 327 else if (align == '<' || align == '=') 328 *n_lpadding = 0; 329 else { 330 /* We should never have an unspecified alignment. */ 331 *n_lpadding = 0; 332 assert(0); 333 } 334 335 *n_rpadding = *n_total - nchars - *n_lpadding; 336 } 337 338 /* Do the padding, and return a pointer to where the caller-supplied 339 content goes. */ 340 static STRINGLIB_CHAR * 341 fill_padding(STRINGLIB_CHAR *p, Py_ssize_t nchars, STRINGLIB_CHAR fill_char, 342 Py_ssize_t n_lpadding, Py_ssize_t n_rpadding) 343 { 344 /* Pad on left. */ 345 if (n_lpadding) 346 STRINGLIB_FILL(p, fill_char, n_lpadding); 347 348 /* Pad on right. */ 349 if (n_rpadding) 350 STRINGLIB_FILL(p + nchars + n_lpadding, fill_char, n_rpadding); 351 352 /* Pointer to the user content. */ 353 return p + n_lpadding; 354 } 355 356 #if defined FORMAT_FLOAT || defined FORMAT_LONG || defined FORMAT_COMPLEX 237 357 /************************************************************************/ 238 358 /*********** common routines for numeric formatting *********************/ 239 359 /************************************************************************/ 360 361 /* Locale type codes. */ 362 #define LT_CURRENT_LOCALE 0 363 #define LT_DEFAULT_LOCALE 1 364 #define LT_NO_LOCALE 2 365 366 /* Locale info needed for formatting integers and the part of floats 367 before and including the decimal. Note that locales only support 368 8-bit chars, not unicode. */ 369 typedef struct { 370 char *decimal_point; 371 char *thousands_sep; 372 char *grouping; 373 } LocaleInfo; 240 374 241 375 /* describes the layout for an integer, see the comment in … … 246 380 Py_ssize_t n_spadding; 247 381 Py_ssize_t n_rpadding; 248 char lsign; 249 Py_ssize_t n_lsign; 250 char rsign; 251 Py_ssize_t n_rsign; 252 Py_ssize_t n_total; /* just a convenience, it's derivable from the 253 other fields */ 382 char sign; 383 Py_ssize_t n_sign; /* number of digits needed for sign (0/1) */ 384 Py_ssize_t n_grouped_digits; /* Space taken up by the digits, including 385 any grouping chars. */ 386 Py_ssize_t n_decimal; /* 0 if only an integer */ 387 Py_ssize_t n_remainder; /* Digits in decimal and/or exponent part, 388 excluding the decimal itself, if 389 present. */ 390 391 /* These 2 are not the widths of fields, but are needed by 392 STRINGLIB_GROUPING. */ 393 Py_ssize_t n_digits; /* The number of digits before a decimal 394 or exponent. */ 395 Py_ssize_t n_min_width; /* The min_width we used when we computed 396 the n_grouped_digits width. */ 254 397 } NumberFieldWidths; 398 399 400 /* Given a number of the form: 401 digits[remainder] 402 where ptr points to the start and end points to the end, find where 403 the integer part ends. This could be a decimal, an exponent, both, 404 or neither. 405 If a decimal point is present, set *has_decimal and increment 406 remainder beyond it. 407 Results are undefined (but shouldn't crash) for improperly 408 formatted strings. 409 */ 410 static void 411 parse_number(STRINGLIB_CHAR *ptr, Py_ssize_t len, 412 Py_ssize_t *n_remainder, int *has_decimal) 413 { 414 STRINGLIB_CHAR *end = ptr + len; 415 STRINGLIB_CHAR *remainder; 416 417 while (ptr<end && isdigit(*ptr)) 418 ++ptr; 419 remainder = ptr; 420 421 /* Does remainder start with a decimal point? */ 422 *has_decimal = ptr<end && *remainder == '.'; 423 424 /* Skip the decimal point. */ 425 if (*has_decimal) 426 remainder++; 427 428 *n_remainder = end - remainder; 429 } 255 430 256 431 /* not all fields of format are used. for example, precision is … … 258 433 about what it does? or is passing a single format parameter easier 259 434 and more efficient enough to justify a little obfuscation? */ 260 static void 261 calc_number_widths(NumberFieldWidths *spec, STRINGLIB_CHAR actual_sign, 262 Py_ssize_t n_prefix, Py_ssize_t n_digits, 263 const InternalFormatSpec *format) 264 { 435 static Py_ssize_t 436 calc_number_widths(NumberFieldWidths *spec, Py_ssize_t n_prefix, 437 STRINGLIB_CHAR sign_char, STRINGLIB_CHAR *number, 438 Py_ssize_t n_number, Py_ssize_t n_remainder, 439 int has_decimal, const LocaleInfo *locale, 440 const InternalFormatSpec *format) 441 { 442 Py_ssize_t n_non_digit_non_padding; 443 Py_ssize_t n_padding; 444 445 spec->n_digits = n_number - n_remainder - (has_decimal?1:0); 265 446 spec->n_lpadding = 0; 266 spec->n_prefix = 0; 447 spec->n_prefix = n_prefix; 448 spec->n_decimal = has_decimal ? strlen(locale->decimal_point) : 0; 449 spec->n_remainder = n_remainder; 267 450 spec->n_spadding = 0; 268 451 spec->n_rpadding = 0; 269 spec->lsign = '\0'; 270 spec->n_lsign = 0; 271 spec->rsign = '\0'; 272 spec->n_rsign = 0; 452 spec->sign = '\0'; 453 spec->n_sign = 0; 273 454 274 455 /* the output will look like: 275 | |276 | <lpadding> < lsign> <prefix> <spadding> <digits> <rsign> <rpadding> |277 | |278 279 lsign and rsign arecomputed from format->sign and the actual456 | | 457 | <lpadding> <sign> <prefix> <spadding> <grouped_digits> <decimal> <remainder> <rpadding> | 458 | | 459 460 sign is computed from format->sign and the actual 280 461 sign of the number 281 462 … … 292 473 293 474 /* compute the various parts we're going to write */ 294 if (format->sign == '+') { 475 switch (format->sign) { 476 case '+': 295 477 /* always put a + or - */ 296 spec->n_lsign = 1; 297 spec->lsign = (actual_sign == '-' ? '-' : '+'); 298 } 299 #if ALLOW_PARENS_FOR_SIGN 300 else if (format->sign == '(') { 301 if (actual_sign == '-') { 302 spec->n_lsign = 1; 303 spec->lsign = '('; 304 spec->n_rsign = 1; 305 spec->rsign = ')'; 478 spec->n_sign = 1; 479 spec->sign = (sign_char == '-' ? '-' : '+'); 480 break; 481 case ' ': 482 spec->n_sign = 1; 483 spec->sign = (sign_char == '-' ? '-' : ' '); 484 break; 485 default: 486 /* Not specified, or the default (-) */ 487 if (sign_char == '-') { 488 spec->n_sign = 1; 489 spec->sign = '-'; 306 490 } 307 491 } 308 #endif 309 else if (format->sign == ' ') { 310 spec->n_lsign = 1; 311 spec->lsign = (actual_sign == '-' ? '-' : ' '); 312 } 313 else { 314 /* non specified, or the default (-) */ 315 if (actual_sign == '-') { 316 spec->n_lsign = 1; 317 spec->lsign = '-'; 492 493 /* The number of chars used for non-digits and non-padding. */ 494 n_non_digit_non_padding = spec->n_sign + spec->n_prefix + spec->n_decimal + 495 spec->n_remainder; 496 497 /* min_width can go negative, that's okay. format->width == -1 means 498 we don't care. */ 499 if (format->fill_char == '0' && format->align == '=') 500 spec->n_min_width = format->width - n_non_digit_non_padding; 501 else 502 spec->n_min_width = 0; 503 504 if (spec->n_digits == 0) 505 /* This case only occurs when using 'c' formatting, we need 506 to special case it because the grouping code always wants 507 to have at least one character. */ 508 spec->n_grouped_digits = 0; 509 else 510 spec->n_grouped_digits = STRINGLIB_GROUPING(NULL, 0, NULL, 511 spec->n_digits, 512 spec->n_min_width, 513 locale->grouping, 514 locale->thousands_sep); 515 516 /* Given the desired width and the total of digit and non-digit 517 space we consume, see if we need any padding. format->width can 518 be negative (meaning no padding), but this code still works in 519 that case. */ 520 n_padding = format->width - 521 (n_non_digit_non_padding + spec->n_grouped_digits); 522 if (n_padding > 0) { 523 /* Some padding is needed. Determine if it's left, space, or right. */ 524 switch (format->align) { 525 case '<': 526 spec->n_rpadding = n_padding; 527 break; 528 case '^': 529 spec->n_lpadding = n_padding / 2; 530 spec->n_rpadding = n_padding - spec->n_lpadding; 531 break; 532 case '=': 533 spec->n_spadding = n_padding; 534 break; 535 case '>': 536 spec->n_lpadding = n_padding; 537 break; 538 default: 539 /* Shouldn't get here, but treat it as '>' */ 540 spec->n_lpadding = n_padding; 541 assert(0); 542 break; 318 543 } 319 544 } 320 321 spec->n_prefix = n_prefix; 322 323 /* now the number of padding characters */ 324 if (format->width == -1) { 325 /* no padding at all, nothing to do */ 326 } 327 else { 328 /* see if any padding is needed */ 329 if (spec->n_lsign + n_digits + spec->n_rsign + 330 spec->n_prefix >= format->width) { 331 /* no padding needed, we're already bigger than the 332 requested width */ 545 return spec->n_lpadding + spec->n_sign + spec->n_prefix + 546 spec->n_spadding + spec->n_grouped_digits + spec->n_decimal + 547 spec->n_remainder + spec->n_rpadding; 548 } 549 550 /* Fill in the digit parts of a numbers's string representation, 551 as determined in calc_number_widths(). 552 No error checking, since we know the buffer is the correct size. */ 553 static void 554 fill_number(STRINGLIB_CHAR *buf, const NumberFieldWidths *spec, 555 STRINGLIB_CHAR *digits, Py_ssize_t n_digits, 556 STRINGLIB_CHAR *prefix, STRINGLIB_CHAR fill_char, 557 LocaleInfo *locale, int toupper) 558 { 559 /* Used to keep track of digits, decimal, and remainder. */ 560 STRINGLIB_CHAR *p = digits; 561 562 #ifndef NDEBUG 563 Py_ssize_t r; 564 #endif 565 566 if (spec->n_lpadding) { 567 STRINGLIB_FILL(buf, fill_char, spec->n_lpadding); 568 buf += spec->n_lpadding; 569 } 570 if (spec->n_sign == 1) { 571 *buf++ = spec->sign; 572 } 573 if (spec->n_prefix) { 574 memmove(buf, 575 prefix, 576 spec->n_prefix * sizeof(STRINGLIB_CHAR)); 577 if (toupper) { 578 Py_ssize_t t; 579 for (t = 0; t < spec->n_prefix; ++t) 580 buf[t] = STRINGLIB_TOUPPER(buf[t]); 333 581 } 334 else { 335 /* determine which of left, space, or right padding is 336 needed */ 337 Py_ssize_t padding = format->width - 338 (spec->n_lsign + spec->n_prefix + 339 n_digits + spec->n_rsign); 340 if (format->align == '<') 341 spec->n_rpadding = padding; 342 else if (format->align == '>') 343 spec->n_lpadding = padding; 344 else if (format->align == '^') { 345 spec->n_lpadding = padding / 2; 346 spec->n_rpadding = padding - spec->n_lpadding; 347 } 348 else if (format->align == '=') 349 spec->n_spadding = padding; 350 else 351 spec->n_lpadding = padding; 352 } 353 } 354 spec->n_total = spec->n_lpadding + spec->n_lsign + spec->n_prefix + 355 spec->n_spadding + n_digits + spec->n_rsign + spec->n_rpadding; 356 } 357 358 /* fill in the non-digit parts of a numbers's string representation, 359 as determined in calc_number_widths(). returns the pointer to 360 where the digits go. */ 361 static STRINGLIB_CHAR * 362 fill_non_digits(STRINGLIB_CHAR *p_buf, const NumberFieldWidths *spec, 363 STRINGLIB_CHAR *prefix, Py_ssize_t n_digits, 364 STRINGLIB_CHAR fill_char) 365 { 366 STRINGLIB_CHAR *p_digits; 367 368 if (spec->n_lpadding) { 369 STRINGLIB_FILL(p_buf, fill_char, spec->n_lpadding); 370 p_buf += spec->n_lpadding; 371 } 372 if (spec->n_lsign == 1) { 373 *p_buf++ = spec->lsign; 374 } 375 if (spec->n_prefix) { 376 memmove(p_buf, 377 prefix, 378 spec->n_prefix * sizeof(STRINGLIB_CHAR)); 379 p_buf += spec->n_prefix; 582 buf += spec->n_prefix; 380 583 } 381 584 if (spec->n_spadding) { 382 STRINGLIB_FILL(p_buf, fill_char, spec->n_spadding); 383 p_buf += spec->n_spadding; 384 } 385 p_digits = p_buf; 386 p_buf += n_digits; 387 if (spec->n_rsign == 1) { 388 *p_buf++ = spec->rsign; 389 } 585 STRINGLIB_FILL(buf, fill_char, spec->n_spadding); 586 buf += spec->n_spadding; 587 } 588 589 /* Only for type 'c' special case, it has no digits. */ 590 if (spec->n_digits != 0) { 591 /* Fill the digits with InsertThousandsGrouping. */ 592 #ifndef NDEBUG 593 r = 594 #endif 595 STRINGLIB_GROUPING(buf, spec->n_grouped_digits, digits, 596 spec->n_digits, spec->n_min_width, 597 locale->grouping, locale->thousands_sep); 598 #ifndef NDEBUG 599 assert(r == spec->n_grouped_digits); 600 #endif 601 p += spec->n_digits; 602 } 603 if (toupper) { 604 Py_ssize_t t; 605 for (t = 0; t < spec->n_grouped_digits; ++t) 606 buf[t] = STRINGLIB_TOUPPER(buf[t]); 607 } 608 buf += spec->n_grouped_digits; 609 610 if (spec->n_decimal) { 611 Py_ssize_t t; 612 for (t = 0; t < spec->n_decimal; ++t) 613 buf[t] = locale->decimal_point[t]; 614 buf += spec->n_decimal; 615 p += 1; 616 } 617 618 if (spec->n_remainder) { 619 memcpy(buf, p, spec->n_remainder * sizeof(STRINGLIB_CHAR)); 620 buf += spec->n_remainder; 621 p += spec->n_remainder; 622 } 623 390 624 if (spec->n_rpadding) { 391 STRINGLIB_FILL(p_buf, fill_char, spec->n_rpadding); 392 p_buf += spec->n_rpadding; 393 } 394 return p_digits; 395 } 396 #endif /* FORMAT_FLOAT || FORMAT_LONG */ 625 STRINGLIB_FILL(buf, fill_char, spec->n_rpadding); 626 buf += spec->n_rpadding; 627 } 628 } 629 630 static char no_grouping[1] = {CHAR_MAX}; 631 632 /* Find the decimal point character(s?), thousands_separator(s?), and 633 grouping description, either for the current locale if type is 634 LT_CURRENT_LOCALE, a hard-coded locale if LT_DEFAULT_LOCALE, or 635 none if LT_NO_LOCALE. */ 636 static void 637 get_locale_info(int type, LocaleInfo *locale_info) 638 { 639 switch (type) { 640 case LT_CURRENT_LOCALE: { 641 struct lconv *locale_data = localeconv(); 642 locale_info->decimal_point = locale_data->decimal_point; 643 locale_info->thousands_sep = locale_data->thousands_sep; 644 locale_info->grouping = locale_data->grouping; 645 break; 646 } 647 case LT_DEFAULT_LOCALE: 648 locale_info->decimal_point = "."; 649 locale_info->thousands_sep = ","; 650 locale_info->grouping = "\3"; /* Group every 3 characters. The 651 (implicit) trailing 0 means repeat 652 infinitely. */ 653 break; 654 case LT_NO_LOCALE: 655 locale_info->decimal_point = "."; 656 locale_info->thousands_sep = ""; 657 locale_info->grouping = no_grouping; 658 break; 659 default: 660 assert(0); 661 } 662 } 663 664 #endif /* FORMAT_FLOAT || FORMAT_LONG || FORMAT_COMPLEX */ 397 665 398 666 /************************************************************************/ … … 403 671 format_string_internal(PyObject *value, const InternalFormatSpec *format) 404 672 { 405 Py_ssize_t width; /* total field width */406 673 Py_ssize_t lpad; 407 STRINGLIB_CHAR *dst; 408 STRINGLIB_CHAR *src = STRINGLIB_STR(value); 674 Py_ssize_t rpad; 675 Py_ssize_t total; 676 STRINGLIB_CHAR *p; 409 677 Py_ssize_t len = STRINGLIB_LEN(value); 410 678 PyObject *result = NULL; … … 421 689 PyErr_SetString(PyExc_ValueError, 422 690 "Alternate form (#) not allowed in string format " 423 691 "specifier"); 424 692 goto done; 425 693 } … … 439 707 } 440 708 441 if (format->width >= 0) { 442 width = format->width; 443 444 /* but use at least len characters */ 445 if (len > width) { 446 width = len; 447 } 448 } 449 else { 450 /* not specified, use all of the chars and no more */ 451 width = len; 452 } 709 calc_padding(len, format->width, format->align, &lpad, &rpad, &total); 453 710 454 711 /* allocate the resulting string */ 455 result = STRINGLIB_NEW(NULL, width);712 result = STRINGLIB_NEW(NULL, total); 456 713 if (result == NULL) 457 714 goto done; 458 715 459 /* now write into that space */ 460 dst = STRINGLIB_STR(result); 461 462 /* figure out how much leading space we need, based on the 463 aligning */ 464 if (format->align == '>') 465 lpad = width - len; 466 else if (format->align == '^') 467 lpad = (width - len) / 2; 468 else 469 lpad = 0; 470 471 /* if right aligning, increment the destination allow space on the 472 left */ 473 memcpy(dst + lpad, src, len * sizeof(STRINGLIB_CHAR)); 474 475 /* do any padding */ 476 if (width > len) { 477 STRINGLIB_CHAR fill_char = format->fill_char; 478 if (fill_char == '\0') { 479 /* use the default, if not specified */ 480 fill_char = ' '; 481 } 482 483 /* pad on left */ 484 if (lpad) 485 STRINGLIB_FILL(dst, fill_char, lpad); 486 487 /* pad on right */ 488 if (width - len - lpad) 489 STRINGLIB_FILL(dst + len + lpad, fill_char, width - len - lpad); 490 } 716 /* Write into that space. First the padding. */ 717 p = fill_padding(STRINGLIB_STR(result), len, 718 format->fill_char=='\0'?' ':format->fill_char, 719 lpad, rpad); 720 721 /* Then the source string. */ 722 memcpy(p, STRINGLIB_STR(value), len * sizeof(STRINGLIB_CHAR)); 491 723 492 724 done: … … 505 737 static PyObject * 506 738 format_int_or_long_internal(PyObject *value, const InternalFormatSpec *format, 507 739 IntOrLongToString tostring) 508 740 { 509 741 PyObject *result = NULL; … … 511 743 STRINGLIB_CHAR *pnumeric_chars; 512 744 STRINGLIB_CHAR numeric_char; 513 STRINGLIB_CHAR sign = '\0'; 514 STRINGLIB_CHAR *p; 745 STRINGLIB_CHAR sign_char = '\0'; 515 746 Py_ssize_t n_digits; /* count of digits need from the computed 516 747 string */ 517 Py_ssize_t n_leading_chars; 518 Py_ssize_t n_grouping_chars = 0; /* Count of additional chars to 519 allocate, used for 'n' 520 formatting. */ 748 Py_ssize_t n_remainder = 0; /* Used only for 'c' formatting, which 749 produces non-digits */ 521 750 Py_ssize_t n_prefix = 0; /* Count of prefix chars, (e.g., '0x') */ 751 Py_ssize_t n_total; 522 752 STRINGLIB_CHAR *prefix = NULL; 523 753 NumberFieldWidths spec; 524 754 long x; 755 756 /* Locale settings, either from the actual locale or 757 from a hard-code pseudo-locale */ 758 LocaleInfo locale; 525 759 526 760 /* no precision allowed on integers */ … … 530 764 goto done; 531 765 } 532 533 766 534 767 /* special case for character formatting */ … … 538 771 PyErr_SetString(PyExc_ValueError, 539 772 "Sign not allowed with integer" 773 " format specifier 'c'"); 774 goto done; 775 } 776 777 /* Error to specify a comma. */ 778 if (format->thousands_separators) { 779 PyErr_SetString(PyExc_ValueError, 780 "Thousands separators not allowed with integer" 540 781 " format specifier 'c'"); 541 782 goto done; … … 563 804 } 564 805 #endif 565 566 806 numeric_char = (STRINGLIB_CHAR)x; 807 pnumeric_chars = &numeric_char; 567 808 n_digits = 1; 809 810 /* As a sort-of hack, we tell calc_number_widths that we only 811 have "remainder" characters. calc_number_widths thinks 812 these are characters that don't get formatted, only copied 813 into the output string. We do this for 'c' formatting, 814 because the characters are likely to be non-digits. */ 815 n_remainder = 1; 568 816 } 569 817 else { 570 818 int base; 571 572 573 819 int leading_chars_to_skip = 0; /* Number of characters added by 820 PyNumber_ToBase that we want to 821 skip over. */ 574 822 575 823 /* Compute the base and how many characters will be added by … … 578 826 case 'b': 579 827 base = 2; 580 828 leading_chars_to_skip = 2; /* 0b */ 581 829 break; 582 830 case 'o': 583 831 base = 8; 584 832 leading_chars_to_skip = 2; /* 0o */ 585 833 break; 586 834 case 'x': 587 835 case 'X': 588 836 base = 16; 589 837 leading_chars_to_skip = 2; /* 0x */ 590 838 break; 591 839 default: /* shouldn't be needed, but stops a compiler warning */ … … 596 844 } 597 845 598 599 600 601 846 /* The number of prefix chars is the same as the leading 847 chars to skip */ 848 if (format->alternate) 849 n_prefix = leading_chars_to_skip; 602 850 603 851 /* Do the hard part, converting to a string in a given base */ 604 852 tmp = tostring(value, base); 605 853 if (tmp == NULL) 606 854 goto done; 607 855 608 856 pnumeric_chars = STRINGLIB_STR(tmp); 609 857 n_digits = STRINGLIB_LEN(tmp); 610 858 611 612 613 614 615 859 prefix = pnumeric_chars; 860 861 /* Remember not to modify what pnumeric_chars points to. it 862 might be interned. Only modify it after we copy it into a 863 newly allocated output buffer. */ 616 864 617 865 /* Is a sign character present in the output? If so, remember it 618 866 and skip it */ 619 sign = pnumeric_chars[0];620 if (sign == '-') {621 622 867 if (pnumeric_chars[0] == '-') { 868 sign_char = pnumeric_chars[0]; 869 ++prefix; 870 ++leading_chars_to_skip; 623 871 } 624 872 625 /* Skip over the leading chars (0x, 0b, etc.) */ 626 n_digits -= leading_chars_to_skip; 627 pnumeric_chars += leading_chars_to_skip; 628 } 629 630 if (format->type == 'n') 631 /* Compute how many additional chars we need to allocate 632 to hold the thousands grouping. */ 633 STRINGLIB_GROUPING(NULL, n_digits, n_digits, 634 0, &n_grouping_chars, 0); 635 636 /* Calculate the widths of the various leading and trailing parts */ 637 calc_number_widths(&spec, sign, n_prefix, n_digits + n_grouping_chars, 638 format); 639 640 /* Allocate a new string to hold the result */ 641 result = STRINGLIB_NEW(NULL, spec.n_total); 873 /* Skip over the leading chars (0x, 0b, etc.) */ 874 n_digits -= leading_chars_to_skip; 875 pnumeric_chars += leading_chars_to_skip; 876 } 877 878 /* Determine the grouping, separator, and decimal point, if any. */ 879 get_locale_info(format->type == 'n' ? LT_CURRENT_LOCALE : 880 (format->thousands_separators ? 881 LT_DEFAULT_LOCALE : 882 LT_NO_LOCALE), 883 &locale); 884 885 /* Calculate how much memory we'll need. */ 886 n_total = calc_number_widths(&spec, n_prefix, sign_char, pnumeric_chars, 887 n_digits, n_remainder, 0, &locale, format); 888 889 /* Allocate the memory. */ 890 result = STRINGLIB_NEW(NULL, n_total); 642 891 if (!result) 643 goto done; 644 p = STRINGLIB_STR(result); 645 646 /* XXX There is too much magic here regarding the internals of 647 spec and the location of the prefix and digits. It would be 648 better if calc_number_widths returned a number of logical 649 offsets into the buffer, and those were used. Maybe in a 650 future code cleanup. */ 651 652 /* Fill in the digit parts */ 653 n_leading_chars = spec.n_lpadding + spec.n_lsign + 654 spec.n_prefix + spec.n_spadding; 655 memmove(p + n_leading_chars, 656 pnumeric_chars, 657 n_digits * sizeof(STRINGLIB_CHAR)); 658 659 /* If type is 'X', convert the filled in digits to uppercase */ 660 if (format->type == 'X') { 661 Py_ssize_t t; 662 for (t = 0; t < n_digits; ++t) 663 p[t + n_leading_chars] = STRINGLIB_TOUPPER(p[t + n_leading_chars]); 664 } 665 666 /* Insert the grouping, if any, after the uppercasing of the digits, so 667 we can ensure that grouping chars won't be affected. */ 668 if (n_grouping_chars) { 669 /* We know this can't fail, since we've already 670 reserved enough space. */ 671 STRINGLIB_CHAR *pstart = p + n_leading_chars; 672 #ifndef NDEBUG 673 int r = 674 #endif 675 STRINGLIB_GROUPING(pstart, n_digits, n_digits, 676 spec.n_total+n_grouping_chars-n_leading_chars, 677 NULL, 0); 678 assert(r); 679 } 680 681 /* Fill in the non-digit parts (padding, sign, etc.) */ 682 fill_non_digits(p, &spec, prefix, n_digits + n_grouping_chars, 683 format->fill_char == '\0' ? ' ' : format->fill_char); 684 685 /* If type is 'X', uppercase the prefix. This has to be done after the 686 prefix is filled in by fill_non_digits */ 687 if (format->type == 'X') { 688 Py_ssize_t t; 689 for (t = 0; t < n_prefix; ++t) 690 p[t + spec.n_lpadding + spec.n_lsign] = 691 STRINGLIB_TOUPPER(p[t + spec.n_lpadding + spec.n_lsign]); 692 } 693 892 goto done; 893 894 /* Populate the memory. */ 895 fill_number(STRINGLIB_STR(result), &spec, pnumeric_chars, n_digits, 896 prefix, format->fill_char == '\0' ? ' ' : format->fill_char, 897 &locale, format->type == 'X'); 694 898 695 899 done: … … 705 909 #ifdef FORMAT_FLOAT 706 910 #if STRINGLIB_IS_UNICODE 707 /* taken from unicodeobject.c */ 708 static Py_ssize_t 709 strtounicode(Py_UNICODE *buffer, const char *charbuffer) 710 { 711 register Py_ssize_t i; 712 Py_ssize_t len = strlen(charbuffer); 713 for (i = len - 1; i >= 0; --i) 714 buffer[i] = (Py_UNICODE) charbuffer[i]; 715 716 return len; 717 } 718 #endif 719 720 /* see FORMATBUFLEN in unicodeobject.c */ 721 #define FLOAT_FORMATBUFLEN 120 911 static void 912 strtounicode(Py_UNICODE *buffer, const char *charbuffer, Py_ssize_t len) 913 { 914 Py_ssize_t i; 915 for (i = 0; i < len; ++i) 916 buffer[i] = (Py_UNICODE)charbuffer[i]; 917 } 918 #endif 722 919 723 920 /* much of this is taken from unicodeobject.c */ 724 921 static PyObject * 725 922 format_float_internal(PyObject *value, 726 const InternalFormatSpec *format) 727 { 728 /* fmt = '%.' + `prec` + `type` + '%%' 729 worst case length = 2 + 10 (len of INT_MAX) + 1 + 2 = 15 (use 20)*/ 730 char fmt[20]; 731 732 /* taken from unicodeobject.c */ 733 /* Worst case length calc to ensure no buffer overrun: 734 735 'g' formats: 736 fmt = %#.<prec>g 737 buf = '-' + [0-9]*prec + '.' + 'e+' + (longest exp 738 for any double rep.) 739 len = 1 + prec + 1 + 2 + 5 = 9 + prec 740 741 'f' formats: 742 buf = '-' + [0-9]*x + '.' + [0-9]*prec (with x < 50) 743 len = 1 + 50 + 1 + prec = 52 + prec 744 745 If prec=0 the effective precision is 1 (the leading digit is 746 always given), therefore increase the length by one. 747 748 */ 749 char charbuf[FLOAT_FORMATBUFLEN]; 923 const InternalFormatSpec *format) 924 { 925 char *buf = NULL; /* buffer returned from PyOS_double_to_string */ 750 926 Py_ssize_t n_digits; 751 double x; 752 Py_ssize_t precision = format->precision; 753 PyObject *result = NULL; 754 STRINGLIB_CHAR sign; 755 char* trailing = ""; 927 Py_ssize_t n_remainder; 928 Py_ssize_t n_total; 929 int has_decimal; 930 double val; 931 Py_ssize_t precision; 932 Py_ssize_t default_precision = 6; 933 STRINGLIB_CHAR type = format->type; 934 int add_pct = 0; 756 935 STRINGLIB_CHAR *p; 757 936 NumberFieldWidths spec; 758 STRINGLIB_CHAR type = format->type; 937 int flags = 0; 938 PyObject *result = NULL; 939 STRINGLIB_CHAR sign_char = '\0'; 940 int float_type; /* Used to see if we have a nan, inf, or regular float. */ 759 941 760 942 #if STRINGLIB_IS_UNICODE 761 Py_UNICODE unicodebuf[FLOAT_FORMATBUFLEN]; 762 #endif 763 764 /* alternate is not allowed on floats. */ 943 Py_UNICODE *unicode_tmp = NULL; 944 #endif 945 946 /* Locale settings, either from the actual locale or 947 from a hard-code pseudo-locale */ 948 LocaleInfo locale; 949 950 if (format->precision > INT_MAX) { 951 PyErr_SetString(PyExc_ValueError, "precision too big"); 952 goto done; 953 } 954 precision = (int)format->precision; 955 956 /* Alternate is not allowed on floats. */ 765 957 if (format->alternate) { 766 958 PyErr_SetString(PyExc_ValueError, 767 959 "Alternate form (#) not allowed in float format " 768 "specifier"); 769 goto done; 770 } 771 772 /* first, do the conversion as 8-bit chars, using the platform's 773 snprintf. then, if needed, convert to unicode. */ 774 775 /* 'F' is the same as 'f', per the PEP */ 776 if (type == 'F') 777 type = 'f'; 778 779 x = PyFloat_AsDouble(value); 780 781 if (x == -1.0 && PyErr_Occurred()) 960 "specifier"); 961 goto done; 962 } 963 964 if (type == '\0') { 965 /* Omitted type specifier. This is like 'g' but with at least one 966 digit after the decimal point, and different default precision.*/ 967 type = 'g'; 968 default_precision = PyFloat_STR_PRECISION; 969 flags |= Py_DTSF_ADD_DOT_0; 970 } 971 972 if (type == 'n') 973 /* 'n' is the same as 'g', except for the locale used to 974 format the result. We take care of that later. */ 975 type = 'g'; 976 977 val = PyFloat_AsDouble(value); 978 if (val == -1.0 && PyErr_Occurred()) 782 979 goto done; 783 980 784 981 if (type == '%') { 785 982 type = 'f'; 786 x*= 100;787 trailing = "%";983 val *= 100; 984 add_pct = 1; 788 985 } 789 986 790 987 if (precision < 0) 791 precision = 6; 792 if (type == 'f' && fabs(x) >= 1e50) 793 type = 'g'; 794 795 /* cast "type", because if we're in unicode we need to pass a 796 8-bit char. this is safe, because we've restricted what "type" 797 can be */ 798 PyOS_snprintf(fmt, sizeof(fmt), "%%.%" PY_FORMAT_SIZE_T "d%c", precision, 799 (char)type); 800 801 /* do the actual formatting */ 802 PyOS_ascii_formatd(charbuf, sizeof(charbuf), fmt, x); 803 804 /* adding trailing to fmt with PyOS_snprintf doesn't work, not 805 sure why. we'll just concatentate it here, no harm done. we 806 know we can't have a buffer overflow from the fmt size 807 analysis */ 808 strcat(charbuf, trailing); 809 810 /* rather than duplicate the code for snprintf for both unicode 811 and 8 bit strings, we just use the 8 bit version and then 812 convert to unicode in a separate code path. that's probably 813 the lesser of 2 evils. */ 988 precision = default_precision; 989 990 /* Cast "type", because if we're in unicode we need to pass a 991 8-bit char. This is safe, because we've restricted what "type" 992 can be. */ 993 buf = PyOS_double_to_string(val, (char)type, precision, flags, 994 &float_type); 995 if (buf == NULL) 996 goto done; 997 n_digits = strlen(buf); 998 999 if (add_pct) { 1000 /* We know that buf has a trailing zero (since we just called 1001 strlen() on it), and we don't use that fact any more. So we 1002 can just write over the trailing zero. */ 1003 buf[n_digits] = '%'; 1004 n_digits += 1; 1005 } 1006 1007 /* Since there is no unicode version of PyOS_double_to_string, 1008 just use the 8 bit version and then convert to unicode. */ 814 1009 #if STRINGLIB_IS_UNICODE 815 n_digits = strtounicode(unicodebuf, charbuf); 816 p = unicodebuf; 1010 unicode_tmp = (Py_UNICODE*)PyMem_Malloc((n_digits)*sizeof(Py_UNICODE)); 1011 if (unicode_tmp == NULL) { 1012 PyErr_NoMemory(); 1013 goto done; 1014 } 1015 strtounicode(unicode_tmp, buf, n_digits); 1016 p = unicode_tmp; 817 1017 #else 818 /* compute the length. I believe this is done because the return 819 value from snprintf above is unreliable */ 820 n_digits = strlen(charbuf); 821 p = charbuf; 822 #endif 823 824 /* is a sign character present in the output? if so, remember it 1018 p = buf; 1019 #endif 1020 1021 /* Is a sign character present in the output? If so, remember it 825 1022 and skip it */ 826 sign = p[0];827 if (sign == '-') {1023 if (*p == '-') { 1024 sign_char = *p; 828 1025 ++p; 829 1026 --n_digits; 830 1027 } 831 1028 832 calc_number_widths(&spec, sign, 0, n_digits, format); 833 834 /* allocate a string with enough space */ 835 result = STRINGLIB_NEW(NULL, spec.n_total); 1029 /* Determine if we have any "remainder" (after the digits, might include 1030 decimal or exponent or both (or neither)) */ 1031 parse_number(p, n_digits, &n_remainder, &has_decimal); 1032 1033 /* Determine the grouping, separator, and decimal point, if any. */ 1034 get_locale_info(format->type == 'n' ? LT_CURRENT_LOCALE : 1035 (format->thousands_separators ? 1036 LT_DEFAULT_LOCALE : 1037 LT_NO_LOCALE), 1038 &locale); 1039 1040 /* Calculate how much memory we'll need. */ 1041 n_total = calc_number_widths(&spec, 0, sign_char, p, n_digits, 1042 n_remainder, has_decimal, &locale, format); 1043 1044 /* Allocate the memory. */ 1045 result = STRINGLIB_NEW(NULL, n_total); 836 1046 if (result == NULL) 837 1047 goto done; 838 1048 839 /* Fill in the non-digit parts (padding, sign, etc.) */ 840 fill_non_digits(STRINGLIB_STR(result), &spec, NULL, n_digits, 841 format->fill_char == '\0' ? ' ' : format->fill_char); 842 843 /* fill in the digit parts */ 844 memmove(STRINGLIB_STR(result) + 845 (spec.n_lpadding + spec.n_lsign + spec.n_spadding), 846 p, 847 n_digits * sizeof(STRINGLIB_CHAR)); 1049 /* Populate the memory. */ 1050 fill_number(STRINGLIB_STR(result), &spec, p, n_digits, NULL, 1051 format->fill_char == '\0' ? ' ' : format->fill_char, &locale, 1052 0); 848 1053 849 1054 done: 1055 PyMem_Free(buf); 1056 #if STRINGLIB_IS_UNICODE 1057 PyMem_Free(unicode_tmp); 1058 #endif 850 1059 return result; 851 1060 } 852 1061 #endif /* FORMAT_FLOAT */ 1062 1063 /************************************************************************/ 1064 /*********** complex formatting *****************************************/ 1065 /************************************************************************/ 1066 1067 #ifdef FORMAT_COMPLEX 1068 1069 static PyObject * 1070 format_complex_internal(PyObject *value, 1071 const InternalFormatSpec *format) 1072 { 1073 double re; 1074 double im; 1075 char *re_buf = NULL; /* buffer returned from PyOS_double_to_string */ 1076 char *im_buf = NULL; /* buffer returned from PyOS_double_to_string */ 1077 1078 InternalFormatSpec tmp_format = *format; 1079 Py_ssize_t n_re_digits; 1080 Py_ssize_t n_im_digits; 1081 Py_ssize_t n_re_remainder; 1082 Py_ssize_t n_im_remainder; 1083 Py_ssize_t n_re_total; 1084 Py_ssize_t n_im_total; 1085 int re_has_decimal; 1086 int im_has_decimal; 1087 Py_ssize_t precision; 1088 Py_ssize_t default_precision = 6; 1089 STRINGLIB_CHAR type = format->type; 1090 STRINGLIB_CHAR *p_re; 1091 STRINGLIB_CHAR *p_im; 1092 NumberFieldWidths re_spec; 1093 NumberFieldWidths im_spec; 1094 int flags = 0; 1095 PyObject *result = NULL; 1096 STRINGLIB_CHAR *p; 1097 STRINGLIB_CHAR re_sign_char = '\0'; 1098 STRINGLIB_CHAR im_sign_char = '\0'; 1099 int re_float_type; /* Used to see if we have a nan, inf, or regular float. */ 1100 int im_float_type; 1101 int add_parens = 0; 1102 int skip_re = 0; 1103 Py_ssize_t lpad; 1104 Py_ssize_t rpad; 1105 Py_ssize_t total; 1106 1107 #if STRINGLIB_IS_UNICODE 1108 Py_UNICODE *re_unicode_tmp = NULL; 1109 Py_UNICODE *im_unicode_tmp = NULL; 1110 #endif 1111 1112 /* Locale settings, either from the actual locale or 1113 from a hard-code pseudo-locale */ 1114 LocaleInfo locale; 1115 1116 if (format->precision > INT_MAX) { 1117 PyErr_SetString(PyExc_ValueError, "precision too big"); 1118 goto done; 1119 } 1120 precision = (int)format->precision; 1121 1122 /* Alternate is not allowed on complex. */ 1123 if (format->alternate) { 1124 PyErr_SetString(PyExc_ValueError, 1125 "Alternate form (#) not allowed in complex format " 1126 "specifier"); 1127 goto done; 1128 } 1129 1130 /* Neither is zero pading. */ 1131 if (format->fill_char == '0') { 1132 PyErr_SetString(PyExc_ValueError, 1133 "Zero padding is not allowed in complex format " 1134 "specifier"); 1135 goto done; 1136 } 1137 1138 /* Neither is '=' alignment . */ 1139 if (format->align == '=') { 1140 PyErr_SetString(PyExc_ValueError, 1141 "'=' alignment flag is not allowed in complex format " 1142 "specifier"); 1143 goto done; 1144 } 1145 1146 re = PyComplex_RealAsDouble(value); 1147 if (re == -1.0 && PyErr_Occurred()) 1148 goto done; 1149 im = PyComplex_ImagAsDouble(value); 1150 if (im == -1.0 && PyErr_Occurred()) 1151 goto done; 1152 1153 if (type == '\0') { 1154 /* Omitted type specifier. Should be like str(self). */ 1155 type = 'g'; 1156 default_precision = PyFloat_STR_PRECISION; 1157 if (re == 0.0 && copysign(1.0, re) == 1.0) 1158 skip_re = 1; 1159 else 1160 add_parens = 1; 1161 } 1162 1163 if (type == 'n') 1164 /* 'n' is the same as 'g', except for the locale used to 1165 format the result. We take care of that later. */ 1166 type = 'g'; 1167 1168 if (precision < 0) 1169 precision = default_precision; 1170 1171 /* Cast "type", because if we're in unicode we need to pass a 1172 8-bit char. This is safe, because we've restricted what "type" 1173 can be. */ 1174 re_buf = PyOS_double_to_string(re, (char)type, precision, flags, 1175 &re_float_type); 1176 if (re_buf == NULL) 1177 goto done; 1178 im_buf = PyOS_double_to_string(im, (char)type, precision, flags, 1179 &im_float_type); 1180 if (im_buf == NULL) 1181 goto done; 1182 1183 n_re_digits = strlen(re_buf); 1184 n_im_digits = strlen(im_buf); 1185 1186 /* Since there is no unicode version of PyOS_double_to_string, 1187 just use the 8 bit version and then convert to unicode. */ 1188 #if STRINGLIB_IS_UNICODE 1189 re_unicode_tmp = (Py_UNICODE*)PyMem_Malloc((n_re_digits)*sizeof(Py_UNICODE)); 1190 if (re_unicode_tmp == NULL) { 1191 PyErr_NoMemory(); 1192 goto done; 1193 } 1194 strtounicode(re_unicode_tmp, re_buf, n_re_digits); 1195 p_re = re_unicode_tmp; 1196 1197 im_unicode_tmp = (Py_UNICODE*)PyMem_Malloc((n_im_digits)*sizeof(Py_UNICODE)); 1198 if (im_unicode_tmp == NULL) { 1199 PyErr_NoMemory(); 1200 goto done; 1201 } 1202 strtounicode(im_unicode_tmp, im_buf, n_im_digits); 1203 p_im = im_unicode_tmp; 1204 #else 1205 p_re = re_buf; 1206 p_im = im_buf; 1207 #endif 1208 1209 /* Is a sign character present in the output? If so, remember it 1210 and skip it */ 1211 if (*p_re == '-') { 1212 re_sign_char = *p_re; 1213 ++p_re; 1214 --n_re_digits; 1215 } 1216 if (*p_im == '-') { 1217 im_sign_char = *p_im; 1218 ++p_im; 1219 --n_im_digits; 1220 } 1221 1222 /* Determine if we have any "remainder" (after the digits, might include 1223 decimal or exponent or both (or neither)) */ 1224 parse_number(p_re, n_re_digits, &n_re_remainder, &re_has_decimal); 1225 parse_number(p_im, n_im_digits, &n_im_remainder, &im_has_decimal); 1226 1227 /* Determine the grouping, separator, and decimal point, if any. */ 1228 get_locale_info(format->type == 'n' ? LT_CURRENT_LOCALE : 1229 (format->thousands_separators ? 1230 LT_DEFAULT_LOCALE : 1231 LT_NO_LOCALE), 1232 &locale); 1233 1234 /* Turn off any padding. We'll do it later after we've composed 1235 the numbers without padding. */ 1236 tmp_format.fill_char = '\0'; 1237 tmp_format.align = '<'; 1238 tmp_format.width = -1; 1239 1240 /* Calculate how much memory we'll need. */ 1241 n_re_total = calc_number_widths(&re_spec, 0, re_sign_char, p_re, 1242 n_re_digits, n_re_remainder, 1243 re_has_decimal, &locale, &tmp_format); 1244 1245 /* Same formatting, but always include a sign, unless the real part is 1246 * going to be omitted, in which case we use whatever sign convention was 1247 * requested by the original format. */ 1248 if (!skip_re) 1249 tmp_format.sign = '+'; 1250 n_im_total = calc_number_widths(&im_spec, 0, im_sign_char, p_im, 1251 n_im_digits, n_im_remainder, 1252 im_has_decimal, &locale, &tmp_format); 1253 1254 if (skip_re) 1255 n_re_total = 0; 1256 1257 /* Add 1 for the 'j', and optionally 2 for parens. */ 1258 calc_padding(n_re_total + n_im_total + 1 + add_parens * 2, 1259 format->width, format->align, &lpad, &rpad, &total); 1260 1261 result = STRINGLIB_NEW(NULL, total); 1262 if (result == NULL) 1263 goto done; 1264 1265 /* Populate the memory. First, the padding. */ 1266 p = fill_padding(STRINGLIB_STR(result), 1267 n_re_total + n_im_total + 1 + add_parens * 2, 1268 format->fill_char=='\0' ? ' ' : format->fill_char, 1269 lpad, rpad); 1270 1271 if (add_parens) 1272 *p++ = '('; 1273 1274 if (!skip_re) { 1275 fill_number(p, &re_spec, p_re, n_re_digits, NULL, 0, &locale, 0); 1276 p += n_re_total; 1277 } 1278 fill_number(p, &im_spec, p_im, n_im_digits, NULL, 0, &locale, 0); 1279 p += n_im_total; 1280 *p++ = 'j'; 1281 1282 if (add_parens) 1283 *p++ = ')'; 1284 1285 done: 1286 PyMem_Free(re_buf); 1287 PyMem_Free(im_buf); 1288 #if STRINGLIB_IS_UNICODE 1289 PyMem_Free(re_unicode_tmp); 1290 PyMem_Free(im_unicode_tmp); 1291 #endif 1292 return result; 1293 } 1294 #endif /* FORMAT_COMPLEX */ 853 1295 854 1296 /************************************************************************/ … … 857 1299 PyObject * 858 1300 FORMAT_STRING(PyObject *obj, 859 860 1301 STRINGLIB_CHAR *format_spec, 1302 Py_ssize_t format_spec_len) 861 1303 { 862 1304 InternalFormatSpec format; … … 872 1314 /* parse the format_spec */ 873 1315 if (!parse_internal_render_format_spec(format_spec, format_spec_len, 874 &format, 's'))1316 &format, 's', '<')) 875 1317 goto done; 876 1318 … … 894 1336 static PyObject* 895 1337 format_int_or_long(PyObject* obj, 896 897 898 1338 STRINGLIB_CHAR *format_spec, 1339 Py_ssize_t format_spec_len, 1340 IntOrLongToString tostring) 899 1341 { 900 1342 PyObject *result = NULL; … … 911 1353 /* parse the format_spec */ 912 1354 if (!parse_internal_render_format_spec(format_spec, 913 914 &format, 'd'))1355 format_spec_len, 1356 &format, 'd', '>')) 915 1357 goto done; 916 1358 … … 925 1367 case 'n': 926 1368 /* no type conversion needed, already an int (or long). do 927 928 1369 the formatting */ 1370 result = format_int_or_long_internal(obj, &format, tostring); 929 1371 break; 930 1372 … … 975 1417 PyObject * 976 1418 FORMAT_LONG(PyObject *obj, 977 978 1419 STRINGLIB_CHAR *format_spec, 1420 Py_ssize_t format_spec_len) 979 1421 { 980 1422 return format_int_or_long(obj, format_spec, format_spec_len, 981 1423 long_format); 982 1424 } 983 1425 #endif /* FORMAT_LONG */ … … 996 1438 PyObject * 997 1439 FORMAT_INT(PyObject *obj, 998 999 1440 STRINGLIB_CHAR *format_spec, 1441 Py_ssize_t format_spec_len) 1000 1442 { 1001 1443 return format_int_or_long(obj, format_spec, format_spec_len, 1002 1444 int_format); 1003 1445 } 1004 1446 #endif /* FORMAT_INT */ … … 1007 1449 PyObject * 1008 1450 FORMAT_FLOAT(PyObject *obj, 1009 1010 1451 STRINGLIB_CHAR *format_spec, 1452 Py_ssize_t format_spec_len) 1011 1453 { 1012 1454 PyObject *result = NULL; … … 1022 1464 /* parse the format_spec */ 1023 1465 if (!parse_internal_render_format_spec(format_spec, 1024 1025 &format, '\0'))1466 format_spec_len, 1467 &format, '\0', '>')) 1026 1468 goto done; 1027 1469 1028 1470 /* type conversion? */ 1029 1471 switch (format.type) { 1030 case '\0': 1031 /* 'Z' means like 'g', but with at least one decimal. See 1032 PyOS_ascii_formatd */ 1033 format.type = 'Z'; 1034 /* Deliberate fall through to the next case statement */ 1472 case '\0': /* No format code: like 'g', but with at least one decimal. */ 1035 1473 case 'e': 1036 1474 case 'E': … … 1055 1493 } 1056 1494 #endif /* FORMAT_FLOAT */ 1495 1496 #ifdef FORMAT_COMPLEX 1497 PyObject * 1498 FORMAT_COMPLEX(PyObject *obj, 1499 STRINGLIB_CHAR *format_spec, 1500 Py_ssize_t format_spec_len) 1501 { 1502 PyObject *result = NULL; 1503 InternalFormatSpec format; 1504 1505 /* check for the special case of zero length format spec, make 1506 it equivalent to str(obj) */ 1507 if (format_spec_len == 0) { 1508 result = STRINGLIB_TOSTR(obj); 1509 goto done; 1510 } 1511 1512 /* parse the format_spec */ 1513 if (!parse_internal_render_format_spec(format_spec, 1514 format_spec_len, 1515 &format, '\0', '>')) 1516 goto done; 1517 1518 /* type conversion? */ 1519 switch (format.type) { 1520 case '\0': /* No format code: like 'g', but with at least one decimal. */ 1521 case 'e': 1522 case 'E': 1523 case 'f': 1524 case 'F': 1525 case 'g': 1526 case 'G': 1527 case 'n': 1528 /* no conversion, already a complex. do the formatting */ 1529 result = format_complex_internal(obj, &format); 1530 break; 1531 1532 default: 1533 /* unknown */ 1534 unknown_presentation_type(format.type, obj->ob_type->tp_name); 1535 goto done; 1536 } 1537 1538 done: 1539 return result; 1540 } 1541 #endif /* FORMAT_COMPLEX */
Note:
See TracChangeset
for help on using the changeset viewer.