1 /* implements the string, long, and float formatters. that is, 2 string.__format__, etc. */ 3 4 #include <locale.h> 5 6 /* Before including this, you must include either: 7 stringlib/unicodedefs.h 8 stringlib/stringdefs.h 9 10 Also, you should define the names: 11 FORMAT_STRING 12 FORMAT_LONG 13 FORMAT_FLOAT 14 FORMAT_COMPLEX 15 to be whatever you want the public names of these functions to 16 be. These are the only non-static functions defined here. 17 */ 18 19 /* Raises an exception about an unknown presentation type for this 20 * type. */ 21 22 static void 23 unknown_presentation_type(STRINGLIB_CHAR presentation_type, 24 const char* type_name) 25 { 26 #if STRINGLIB_IS_UNICODE 27 /* If STRINGLIB_CHAR is Py_UNICODE, %c might be out-of-range, 28 hence the two cases. If it is char, gcc complains that the 29 condition below is always true, hence the ifdef. */ 30 if (presentation_type > 32 && presentation_type < 128) 31 #endif 32 PyErr_Format(PyExc_ValueError, 33 "Unknown format code '%c' " 34 "for object of type '%.200s'", 35 (char)presentation_type, 36 type_name); 37 #if STRINGLIB_IS_UNICODE 38 else 39 PyErr_Format(PyExc_ValueError, 40 "Unknown format code '\\x%x' " 41 "for object of type '%.200s'", 42 (unsigned int)presentation_type, 43 type_name); 44 #endif 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 65 /* 66 get_integer consumes 0 or more decimal digit characters from an 67 input string, updates *result with the corresponding positive 68 integer, and returns the number of digits consumed. 69 70 returns -1 on error. 71 */ 72 static int 73 get_integer(STRINGLIB_CHAR **ptr, STRINGLIB_CHAR *end, 74 Py_ssize_t *result) 75 { 76 Py_ssize_t accumulator, digitval; 77 int numdigits; 78 accumulator = numdigits = 0; 79 for (;;(*ptr)++, numdigits++) { 80 if (*ptr >= end) 81 break; 82 digitval = STRINGLIB_TODECIMAL(**ptr); 83 if (digitval < 0) 84 break; 85 /* 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. 90 */ 91 if (accumulator > (PY_SSIZE_T_MAX - digitval) / 10) { 92 PyErr_Format(PyExc_ValueError, 93 "Too many decimal digits in format string"); 94 return -1; 95 } 96 accumulator = accumulator * 10 + digitval; 97 } 98 *result = accumulator; 99 return numdigits; 100 } 101 102 /************************************************************************/ 103 /*********** standard format specifier parsing **************************/ 104 /************************************************************************/ 105 106 /* returns true if this character is a specifier alignment token */ 107 Py_LOCAL_INLINE(int) 108 is_alignment_token(STRINGLIB_CHAR c) 109 { 110 switch (c) { 111 case '<': case '>': case '=': case '^': 112 return 1; 113 default: 114 return 0; 115 } 116 } 117 118 /* returns true if this character is a sign element */ 119 Py_LOCAL_INLINE(int) 120 is_sign_element(STRINGLIB_CHAR c) 121 { 122 switch (c) { 123 case ' ': case '+': case '-': 124 return 1; 125 default: 126 return 0; 127 } 128 } 129 130 131 typedef struct { 132 STRINGLIB_CHAR fill_char; 133 STRINGLIB_CHAR align; 134 int alternate; 135 STRINGLIB_CHAR sign; 136 Py_ssize_t width; 137 int thousands_separators; 138 Py_ssize_t precision; 139 STRINGLIB_CHAR type; 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 161 162 /* 163 ptr points to the start of the format_spec, end points just past its end. 164 fills in format with the parsed information. 165 returns 1 on success, 0 on failure. 166 if failure, sets the exception 167 */ 168 static int 169 parse_internal_render_format_spec(STRINGLIB_CHAR *format_spec, 170 Py_ssize_t format_spec_len, 171 InternalFormatSpec *format, 172 char default_type, 173 char default_align) 174 { 175 STRINGLIB_CHAR *ptr = format_spec; 176 STRINGLIB_CHAR *end = format_spec + format_spec_len; 177 178 /* end-ptr is used throughout this code to specify the length of 179 the input string */ 180 181 Py_ssize_t consumed; 182 int align_specified = 0; 183 int fill_char_specified = 0; 184 185 format->fill_char = ' '; 186 format->align = default_align; 187 format->alternate = 0; 188 format->sign = '\0'; 189 format->width = -1; 190 format->thousands_separators = 0; 191 format->precision = -1; 192 format->type = default_type; 193 194 /* If the second char is an alignment token, 195 then parse the fill char */ 196 if (end-ptr >= 2 && is_alignment_token(ptr[1])) { 197 format->align = ptr[1]; 198 format->fill_char = ptr[0]; 199 fill_char_specified = 1; 200 align_specified = 1; 201 ptr += 2; 202 } 203 else if (end-ptr >= 1 && is_alignment_token(ptr[0])) { 204 format->align = ptr[0]; 205 align_specified = 1; 206 ++ptr; 207 } 208 209 /* Parse the various sign options */ 210 if (end-ptr >= 1 && is_sign_element(ptr[0])) { 211 format->sign = ptr[0]; 212 ++ptr; 213 } 214 215 /* If the next character is #, we're in alternate mode. This only 216 applies to integers. */ 217 if (end-ptr >= 1 && ptr[0] == '#') { 218 format->alternate = 1; 219 ++ptr; 220 } 221 222 /* The special case for 0-padding (backwards compat) */ 223 if (!fill_char_specified && end-ptr >= 1 && ptr[0] == '0') { 224 format->fill_char = '0'; 225 if (!align_specified) { 226 format->align = '='; 227 } 228 ++ptr; 229 } 230 231 consumed = get_integer(&ptr, end, &format->width); 232 if (consumed == -1) 233 /* Overflow error. Exception already set. */ 234 return 0; 235 236 /* If consumed is 0, we didn't consume any characters for the 237 width. In that case, reset the width to -1, because 238 get_integer() will have set it to zero. -1 is how we record 239 that the width wasn't specified. */ 240 if (consumed == 0) 241 format->width = -1; 242 243 /* Comma signifies add thousands separators */ 244 if (end-ptr && ptr[0] == ',') { 245 format->thousands_separators = 1; 246 ++ptr; 247 } 248 249 /* Parse field precision */ 250 if (end-ptr && ptr[0] == '.') { 251 ++ptr; 252 253 consumed = get_integer(&ptr, end, &format->precision); 254 if (consumed == -1) 255 /* Overflow error. Exception already set. */ 256 return 0; 257 258 /* Not having a precision after a dot is an error. */ 259 if (consumed == 0) { 260 PyErr_Format(PyExc_ValueError, 261 "Format specifier missing precision"); 262 return 0; 263 } 264 265 } 266 267 /* Finally, parse the type field. */ 268 269 if (end-ptr > 1) { 270 /* More than one char remain, invalid conversion spec. */ 271 PyErr_Format(PyExc_ValueError, "Invalid conversion specification"); 272 return 0; 273 } 274 275 if (end-ptr == 1) { 276 format->type = ptr[0]; 277 ++ptr; 278 } 279 280 /* Do as much validating as we can, just by looking at the format 281 specifier. Do not take into account what type of formatting 282 we're doing (int, float, string). */ 283 284 if (format->thousands_separators) { 285 switch (format->type) { 286 case 'd': 287 case 'e': 288 case 'f': 289 case 'g': 290 case 'E': 291 case 'G': 292 case '%': 293 case 'F': 294 case '\0': 295 /* These are allowed. See PEP 378.*/ 296 break; 297 default: 298 invalid_comma_type(format->type); 299 return 0; 300 } 301 } 302 303 return 1; 304 } 305 306 /* Calculate the padding needed. */ 307 static void 308 calc_padding(Py_ssize_t nchars, Py_ssize_t width, STRINGLIB_CHAR align, 309 Py_ssize_t *n_lpadding, Py_ssize_t *n_rpadding, 310 Py_ssize_t *n_total) 311 { 312 if (width >= 0) { 313 if (nchars > width) 314 *n_total = nchars; 315 else 316 *n_total = width; 317 } 318 else { 319 /* not specified, use all of the chars and no more */ 320 *n_total = nchars; 321 } 322 323 /* Figure out how much leading space we need, based on the 324 aligning */ 325 if (align == '>') 326 *n_lpadding = *n_total - nchars; 327 else if (align == '^') 328 *n_lpadding = (*n_total - nchars) / 2; 329 else if (align == '<' || align == '=') 330 *n_lpadding = 0; 331 else { 332 /* We should never have an unspecified alignment. */ 333 *n_lpadding = 0; 334 assert(0); 335 } 336 337 *n_rpadding = *n_total - nchars - *n_lpadding; 338 } 339 340 /* Do the padding, and return a pointer to where the caller-supplied 341 content goes. */ 342 static STRINGLIB_CHAR * 343 fill_padding(STRINGLIB_CHAR *p, Py_ssize_t nchars, STRINGLIB_CHAR fill_char, 344 Py_ssize_t n_lpadding, Py_ssize_t n_rpadding) 345 { 346 /* Pad on left. */ 347 if (n_lpadding) 348 STRINGLIB_FILL(p, fill_char, n_lpadding); 349 350 /* Pad on right. */ 351 if (n_rpadding) 352 STRINGLIB_FILL(p + nchars + n_lpadding, fill_char, n_rpadding); 353 354 /* Pointer to the user content. */ 355 return p + n_lpadding; 356 } 357 358 #if defined FORMAT_FLOAT || defined FORMAT_LONG || defined FORMAT_COMPLEX 359 /************************************************************************/ 360 /*********** common routines for numeric formatting *********************/ 361 /************************************************************************/ 362 363 /* Locale type codes. */ 364 #define LT_CURRENT_LOCALE 0 365 #define LT_DEFAULT_LOCALE 1 366 #define LT_NO_LOCALE 2 367 368 /* Locale info needed for formatting integers and the part of floats 369 before and including the decimal. Note that locales only support 370 8-bit chars, not unicode. */ 371 typedef struct { 372 char *decimal_point; 373 char *thousands_sep; 374 char *grouping; 375 } LocaleInfo; 376 377 /* describes the layout for an integer, see the comment in 378 calc_number_widths() for details */ 379 typedef struct { 380 Py_ssize_t n_lpadding; 381 Py_ssize_t n_prefix; 382 Py_ssize_t n_spadding; 383 Py_ssize_t n_rpadding; 384 char sign; 385 Py_ssize_t n_sign; /* number of digits needed for sign (0/1) */ 386 Py_ssize_t n_grouped_digits; /* Space taken up by the digits, including 387 any grouping chars. */ 388 Py_ssize_t n_decimal; /* 0 if only an integer */ 389 Py_ssize_t n_remainder; /* Digits in decimal and/or exponent part, 390 excluding the decimal itself, if 391 present. */ 392 393 /* These 2 are not the widths of fields, but are needed by 394 STRINGLIB_GROUPING. */ 395 Py_ssize_t n_digits; /* The number of digits before a decimal 396 or exponent. */ 397 Py_ssize_t n_min_width; /* The min_width we used when we computed 398 the n_grouped_digits width. */ 399 } NumberFieldWidths; 400 401 402 /* Given a number of the form: 403 digits[remainder] 404 where ptr points to the start and end points to the end, find where 405 the integer part ends. This could be a decimal, an exponent, both, 406 or neither. 407 If a decimal point is present, set *has_decimal and increment 408 remainder beyond it. 409 Results are undefined (but shouldn't crash) for improperly 410 formatted strings. 411 */ 412 static void 413 parse_number(STRINGLIB_CHAR *ptr, Py_ssize_t len, 414 Py_ssize_t *n_remainder, int *has_decimal) 415 { 416 STRINGLIB_CHAR *end = ptr + len; 417 STRINGLIB_CHAR *remainder; 418 419 while (ptr<end && isdigit(*ptr)) 420 ++ptr; 421 remainder = ptr; 422 423 /* Does remainder start with a decimal point? */ 424 *has_decimal = ptr<end && *remainder == '.'; 425 426 /* Skip the decimal point. */ 427 if (*has_decimal) 428 remainder++; 429 430 *n_remainder = end - remainder; 431 } 432 433 /* not all fields of format are used. for example, precision is 434 unused. should this take discrete params in order to be more clear 435 about what it does? or is passing a single format parameter easier 436 and more efficient enough to justify a little obfuscation? */ 437 static Py_ssize_t 438 calc_number_widths(NumberFieldWidths *spec, Py_ssize_t n_prefix, 439 STRINGLIB_CHAR sign_char, STRINGLIB_CHAR *number, 440 Py_ssize_t n_number, Py_ssize_t n_remainder, 441 int has_decimal, const LocaleInfo *locale, 442 const InternalFormatSpec *format) 443 { 444 Py_ssize_t n_non_digit_non_padding; 445 Py_ssize_t n_padding; 446 447 spec->n_digits = n_number - n_remainder - (has_decimal?1:0); 448 spec->n_lpadding = 0; 449 spec->n_prefix = n_prefix; 450 spec->n_decimal = has_decimal ? strlen(locale->decimal_point) : 0; 451 spec->n_remainder = n_remainder; 452 spec->n_spadding = 0; 453 spec->n_rpadding = 0; 454 spec->sign = '\0'; 455 spec->n_sign = 0; 456 457 /* the output will look like: 458 | | 459 | <lpadding> <sign> <prefix> <spadding> <grouped_digits> <decimal> <remainder> <rpadding> | 460 | | 461 462 sign is computed from format->sign and the actual 463 sign of the number 464 465 prefix is given (it's for the '0x' prefix) 466 467 digits is already known 468 469 the total width is either given, or computed from the 470 actual digits 471 472 only one of lpadding, spadding, and rpadding can be non-zero, 473 and it's calculated from the width and other fields 474 */ 475 476 /* compute the various parts we're going to write */ 477 switch (format->sign) { 478 case '+': 479 /* always put a + or - */ 480 spec->n_sign = 1; 481 spec->sign = (sign_char == '-' ? '-' : '+'); 482 break; 483 case ' ': 484 spec->n_sign = 1; 485 spec->sign = (sign_char == '-' ? '-' : ' '); 486 break; 487 default: 488 /* Not specified, or the default (-) */ 489 if (sign_char == '-') { 490 spec->n_sign = 1; 491 spec->sign = '-'; 492 } 493 } 494 495 /* The number of chars used for non-digits and non-padding. */ 496 n_non_digit_non_padding = spec->n_sign + spec->n_prefix + spec->n_decimal + 497 spec->n_remainder; 498 499 /* min_width can go negative, that's okay. format->width == -1 means 500 we don't care. */ 501 if (format->fill_char == '0' && format->align == '=') 502 spec->n_min_width = format->width - n_non_digit_non_padding; 503 else 504 spec->n_min_width = 0; 505 506 if (spec->n_digits == 0) 507 /* This case only occurs when using 'c' formatting, we need 508 to special case it because the grouping code always wants 509 to have at least one character. */ 510 spec->n_grouped_digits = 0; 511 else 512 spec->n_grouped_digits = STRINGLIB_GROUPING(NULL, 0, NULL, 513 spec->n_digits, 514 spec->n_min_width, 515 locale->grouping, 516 locale->thousands_sep); 517 518 /* Given the desired width and the total of digit and non-digit 519 space we consume, see if we need any padding. format->width can 520 be negative (meaning no padding), but this code still works in 521 that case. */ 522 n_padding = format->width - 523 (n_non_digit_non_padding + spec->n_grouped_digits); 524 if (n_padding > 0) { 525 /* Some padding is needed. Determine if it's left, space, or right. */ 526 switch (format->align) { 527 case '<': 528 spec->n_rpadding = n_padding; 529 break; 530 case '^': 531 spec->n_lpadding = n_padding / 2; 532 spec->n_rpadding = n_padding - spec->n_lpadding; 533 break; 534 case '=': 535 spec->n_spadding = n_padding; 536 break; 537 case '>': 538 spec->n_lpadding = n_padding; 539 break; 540 default: 541 /* Shouldn't get here, but treat it as '>' */ 542 spec->n_lpadding = n_padding; 543 assert(0); 544 break; 545 } 546 } 547 return spec->n_lpadding + spec->n_sign + spec->n_prefix + 548 spec->n_spadding + spec->n_grouped_digits + spec->n_decimal + 549 spec->n_remainder + spec->n_rpadding; 550 } 551 552 /* Fill in the digit parts of a numbers's string representation, 553 as determined in calc_number_widths(). 554 No error checking, since we know the buffer is the correct size. */ 555 static void 556 fill_number(STRINGLIB_CHAR *buf, const NumberFieldWidths *spec, 557 STRINGLIB_CHAR *digits, Py_ssize_t n_digits, 558 STRINGLIB_CHAR *prefix, STRINGLIB_CHAR fill_char, 559 LocaleInfo *locale, int toupper) 560 { 561 /* Used to keep track of digits, decimal, and remainder. */ 562 STRINGLIB_CHAR *p = digits; 563 564 #ifndef NDEBUG 565 Py_ssize_t r; 566 #endif 567 568 if (spec->n_lpadding) { 569 STRINGLIB_FILL(buf, fill_char, spec->n_lpadding); 570 buf += spec->n_lpadding; 571 } 572 if (spec->n_sign == 1) { 573 *buf++ = spec->sign; 574 } 575 if (spec->n_prefix) { 576 memmove(buf, 577 prefix, 578 spec->n_prefix * sizeof(STRINGLIB_CHAR)); 579 if (toupper) { 580 Py_ssize_t t; 581 for (t = 0; t < spec->n_prefix; ++t) 582 buf[t] = STRINGLIB_TOUPPER(buf[t]); 583 } 584 buf += spec->n_prefix; 585 } 586 if (spec->n_spadding) { 587 STRINGLIB_FILL(buf, fill_char, spec->n_spadding); 588 buf += spec->n_spadding; 589 } 590 591 /* Only for type 'c' special case, it has no digits. */ 592 if (spec->n_digits != 0) { 593 /* Fill the digits with InsertThousandsGrouping. */ 594 #ifndef NDEBUG 595 r = 596 #endif 597 STRINGLIB_GROUPING(buf, spec->n_grouped_digits, digits, 598 spec->n_digits, spec->n_min_width, 599 locale->grouping, locale->thousands_sep); 600 #ifndef NDEBUG 601 assert(r == spec->n_grouped_digits); 602 #endif 603 p += spec->n_digits; 604 } 605 if (toupper) { 606 Py_ssize_t t; 607 for (t = 0; t < spec->n_grouped_digits; ++t) 608 buf[t] = STRINGLIB_TOUPPER(buf[t]); 609 } 610 buf += spec->n_grouped_digits; 611 612 if (spec->n_decimal) { 613 Py_ssize_t t; 614 for (t = 0; t < spec->n_decimal; ++t) 615 buf[t] = locale->decimal_point[t]; 616 buf += spec->n_decimal; 617 p += 1; 618 } 619 620 if (spec->n_remainder) { 621 memcpy(buf, p, spec->n_remainder * sizeof(STRINGLIB_CHAR)); 622 buf += spec->n_remainder; 623 p += spec->n_remainder; 624 } 625 626 if (spec->n_rpadding) { 627 STRINGLIB_FILL(buf, fill_char, spec->n_rpadding); 628 buf += spec->n_rpadding; 629 } 630 } 631 632 static char no_grouping[1] = {CHAR_MAX}; 633 634 /* Find the decimal point character(s?), thousands_separator(s?), and 635 grouping description, either for the current locale if type is 636 LT_CURRENT_LOCALE, a hard-coded locale if LT_DEFAULT_LOCALE, or 637 none if LT_NO_LOCALE. */ 638 static void 639 get_locale_info(int type, LocaleInfo *locale_info) 640 { 641 switch (type) { 642 case LT_CURRENT_LOCALE: { 643 struct lconv *locale_data = localeconv(); 644 locale_info->decimal_point = locale_data->decimal_point; 645 locale_info->thousands_sep = locale_data->thousands_sep; 646 locale_info->grouping = locale_data->grouping; 647 break; 648 } 649 case LT_DEFAULT_LOCALE: 650 locale_info->decimal_point = "."; 651 locale_info->thousands_sep = ","; 652 locale_info->grouping = "\3"; /* Group every 3 characters. The 653 (implicit) trailing 0 means repeat 654 infinitely. */ 655 break; 656 case LT_NO_LOCALE: 657 locale_info->decimal_point = "."; 658 locale_info->thousands_sep = ""; 659 locale_info->grouping = no_grouping; 660 break; 661 default: 662 assert(0); 663 } 664 } 665 666 #endif /* FORMAT_FLOAT || FORMAT_LONG || FORMAT_COMPLEX */ 667 668 /************************************************************************/ 669 /*********** string formatting ******************************************/ 670 /************************************************************************/ 671 672 static PyObject * 673 format_string_internal(PyObject *value, const InternalFormatSpec *format) 674 { 675 Py_ssize_t lpad; 676 Py_ssize_t rpad; 677 Py_ssize_t total; 678 STRINGLIB_CHAR *p; 679 Py_ssize_t len = STRINGLIB_LEN(value); 680 PyObject *result = NULL; 681 682 /* sign is not allowed on strings */ 683 if (format->sign != '\0') { 684 PyErr_SetString(PyExc_ValueError, 685 "Sign not allowed in string format specifier"); 686 goto done; 687 } 688 689 /* alternate is not allowed on strings */ 690 if (format->alternate) { 691 PyErr_SetString(PyExc_ValueError, 692 "Alternate form (#) not allowed in string format " 693 "specifier"); 694 goto done; 695 } 696 697 /* '=' alignment not allowed on strings */ 698 if (format->align == '=') { 699 PyErr_SetString(PyExc_ValueError, 700 "'=' alignment not allowed " 701 "in string format specifier"); 702 goto done; 703 } 704 705 /* if precision is specified, output no more that format.precision 706 characters */ 707 if (format->precision >= 0 && len >= format->precision) { 708 len = format->precision; 709 } 710 711 calc_padding(len, format->width, format->align, &lpad, &rpad, &total); 712 713 /* allocate the resulting string */ 714 result = STRINGLIB_NEW(NULL, total); 715 if (result == NULL) 716 goto done; 717 718 /* Write into that space. First the padding. */ 719 p = fill_padding(STRINGLIB_STR(result), len, 720 format->fill_char, lpad, rpad); 721 722 /* Then the source string. */ 723 memcpy(p, STRINGLIB_STR(value), len * sizeof(STRINGLIB_CHAR)); 724 725 done: 726 return result; 727 } 728 729 730 /************************************************************************/ 731 /*********** long formatting ********************************************/ 732 /************************************************************************/ 733 734 #if defined FORMAT_LONG || defined FORMAT_INT 735 typedef PyObject* 736 (*IntOrLongToString)(PyObject *value, int base); 737 738 static PyObject * 739 format_int_or_long_internal(PyObject *value, const InternalFormatSpec *format, 740 IntOrLongToString tostring) 741 { 742 PyObject *result = NULL; 743 PyObject *tmp = NULL; 744 STRINGLIB_CHAR *pnumeric_chars; 745 STRINGLIB_CHAR numeric_char; 746 STRINGLIB_CHAR sign_char = '\0'; 747 Py_ssize_t n_digits; /* count of digits need from the computed 748 string */ 749 Py_ssize_t n_remainder = 0; /* Used only for 'c' formatting, which 750 produces non-digits */ 751 Py_ssize_t n_prefix = 0; /* Count of prefix chars, (e.g., '0x') */ 752 Py_ssize_t n_total; 753 STRINGLIB_CHAR *prefix = NULL; 754 NumberFieldWidths spec; 755 long x; 756 757 /* Locale settings, either from the actual locale or 758 from a hard-code pseudo-locale */ 759 LocaleInfo locale; 760 761 /* no precision allowed on integers */ 762 if (format->precision != -1) { 763 PyErr_SetString(PyExc_ValueError, 764 "Precision not allowed in integer format specifier"); 765 goto done; 766 } 767 768 /* special case for character formatting */ 769 if (format->type == 'c') { 770 /* error to specify a sign */ 771 if (format->sign != '\0') { 772 PyErr_SetString(PyExc_ValueError, 773 "Sign not allowed with integer" 774 " format specifier 'c'"); 775 goto done; 776 } 777 778 /* Error to specify a comma. */ 779 if (format->thousands_separators) { 780 PyErr_SetString(PyExc_ValueError, 781 "Thousands separators not allowed with integer" 782 " format specifier 'c'"); 783 goto done; 784 } 785 786 /* taken from unicodeobject.c formatchar() */ 787 /* Integer input truncated to a character */ 788 /* XXX: won't work for int */ 789 x = PyLong_AsLong(value); 790 if (x == -1 && PyErr_Occurred()) 791 goto done; 792 #ifdef Py_UNICODE_WIDE 793 if (x < 0 || x > 0x10ffff) { 794 PyErr_SetString(PyExc_OverflowError, 795 "%c arg not in range(0x110000) " 796 "(wide Python build)"); 797 goto done; 798 } 799 #else 800 if (x < 0 || x > 0xffff) { 801 PyErr_SetString(PyExc_OverflowError, 802 "%c arg not in range(0x10000) " 803 "(narrow Python build)"); 804 goto done; 805 } 806 #endif 807 numeric_char = (STRINGLIB_CHAR)x; 808 pnumeric_chars = &numeric_char; 809 n_digits = 1; 810 811 /* As a sort-of hack, we tell calc_number_widths that we only 812 have "remainder" characters. calc_number_widths thinks 813 these are characters that don't get formatted, only copied 814 into the output string. We do this for 'c' formatting, 815 because the characters are likely to be non-digits. */ 816 n_remainder = 1; 817 } 818 else { 819 int base; 820 int leading_chars_to_skip = 0; /* Number of characters added by 821 PyNumber_ToBase that we want to 822 skip over. */ 823 824 /* Compute the base and how many characters will be added by 825 PyNumber_ToBase */ 826 switch (format->type) { 827 case 'b': 828 base = 2; 829 leading_chars_to_skip = 2; /* 0b */ 830 break; 831 case 'o': 832 base = 8; 833 leading_chars_to_skip = 2; /* 0o */ 834 break; 835 case 'x': 836 case 'X': 837 base = 16; 838 leading_chars_to_skip = 2; /* 0x */ 839 break; 840 default: /* shouldn't be needed, but stops a compiler warning */ 841 case 'd': 842 case 'n': 843 base = 10; 844 break; 845 } 846 847 /* The number of prefix chars is the same as the leading 848 chars to skip */ 849 if (format->alternate) 850 n_prefix = leading_chars_to_skip; 851 852 /* Do the hard part, converting to a string in a given base */ 853 tmp = tostring(value, base); 854 if (tmp == NULL) 855 goto done; 856 857 pnumeric_chars = STRINGLIB_STR(tmp); 858 n_digits = STRINGLIB_LEN(tmp); 859 860 prefix = pnumeric_chars; 861 862 /* Remember not to modify what pnumeric_chars points to. it 863 might be interned. Only modify it after we copy it into a 864 newly allocated output buffer. */ 865 866 /* Is a sign character present in the output? If so, remember it 867 and skip it */ 868 if (pnumeric_chars[0] == '-') { 869 sign_char = pnumeric_chars[0]; 870 ++prefix; 871 ++leading_chars_to_skip; 872 } 873 874 /* Skip over the leading chars (0x, 0b, etc.) */ 875 n_digits -= leading_chars_to_skip; 876 pnumeric_chars += leading_chars_to_skip; 877 } 878 879 /* Determine the grouping, separator, and decimal point, if any. */ 880 get_locale_info(format->type == 'n' ? LT_CURRENT_LOCALE : 881 (format->thousands_separators ? 882 LT_DEFAULT_LOCALE : 883 LT_NO_LOCALE), 884 &locale); 885 886 /* Calculate how much memory we'll need. */ 887 n_total = calc_number_widths(&spec, n_prefix, sign_char, pnumeric_chars, 888 n_digits, n_remainder, 0, &locale, format); 889 890 /* Allocate the memory. */ 891 result = STRINGLIB_NEW(NULL, n_total); 892 if (!result) 893 goto done; 894 895 /* Populate the memory. */ 896 fill_number(STRINGLIB_STR(result), &spec, pnumeric_chars, n_digits, 897 prefix, format->fill_char, &locale, format->type == 'X'); 898 899 done: 900 Py_XDECREF(tmp); 901 return result; 902 } 903 #endif /* defined FORMAT_LONG || defined FORMAT_INT */ 904 905 /************************************************************************/ 906 /*********** float formatting *******************************************/ 907 /************************************************************************/ 908 909 #ifdef FORMAT_FLOAT 910 #if STRINGLIB_IS_UNICODE 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 919 920 /* much of this is taken from unicodeobject.c */ 921 static PyObject * 922 format_float_internal(PyObject *value, 923 const InternalFormatSpec *format) 924 { 925 char *buf = NULL; /* buffer returned from PyOS_double_to_string */ 926 Py_ssize_t n_digits; 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; 935 STRINGLIB_CHAR *p; 936 NumberFieldWidths spec; 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. */ 941 942 #if STRINGLIB_IS_UNICODE 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. */ 957 if (format->alternate) { 958 PyErr_SetString(PyExc_ValueError, 959 "Alternate form (#) not allowed in float format " 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()) 979 goto done; 980 981 if (type == '%') { 982 type = 'f'; 983 val *= 100; 984 add_pct = 1; 985 } 986 987 if (precision < 0) 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. */ 1009 #if STRINGLIB_IS_UNICODE 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; 1017 #else 1018 p = buf; 1019 #endif 1020 1021 /* Is a sign character present in the output? If so, remember it 1022 and skip it */ 1023 if (*p == '-') { 1024 sign_char = *p; 1025 ++p; 1026 --n_digits; 1027 } 1028 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); 1046 if (result == NULL) 1047 goto done; 1048 1049 /* Populate the memory. */ 1050 fill_number(STRINGLIB_STR(result), &spec, p, n_digits, NULL, 1051 format->fill_char, &locale, 0); 1052 1053 done: 1054 PyMem_Free(buf); 1055 #if STRINGLIB_IS_UNICODE 1056 PyMem_Free(unicode_tmp); 1057 #endif 1058 return result; 1059 } 1060 #endif /* FORMAT_FLOAT */ 1061 1062 /************************************************************************/ 1063 /*********** complex formatting *****************************************/ 1064 /************************************************************************/ 1065 1066 #ifdef FORMAT_COMPLEX 1067 1068 static PyObject * 1069 format_complex_internal(PyObject *value, 1070 const InternalFormatSpec *format) 1071 { 1072 double re; 1073 double im; 1074 char *re_buf = NULL; /* buffer returned from PyOS_double_to_string */ 1075 char *im_buf = NULL; /* buffer returned from PyOS_double_to_string */ 1076 1077 InternalFormatSpec tmp_format = *format; 1078 Py_ssize_t n_re_digits; 1079 Py_ssize_t n_im_digits; 1080 Py_ssize_t n_re_remainder; 1081 Py_ssize_t n_im_remainder; 1082 Py_ssize_t n_re_total; 1083 Py_ssize_t n_im_total; 1084 int re_has_decimal; 1085 int im_has_decimal; 1086 Py_ssize_t precision; 1087 Py_ssize_t default_precision = 6; 1088 STRINGLIB_CHAR type = format->type; 1089 STRINGLIB_CHAR *p_re; 1090 STRINGLIB_CHAR *p_im; 1091 NumberFieldWidths re_spec; 1092 NumberFieldWidths im_spec; 1093 int flags = 0; 1094 PyObject *result = NULL; 1095 STRINGLIB_CHAR *p; 1096 STRINGLIB_CHAR re_sign_char = '\0'; 1097 STRINGLIB_CHAR im_sign_char = '\0'; 1098 int re_float_type; /* Used to see if we have a nan, inf, or regular float. */ 1099 int im_float_type; 1100 int add_parens = 0; 1101 int skip_re = 0; 1102 Py_ssize_t lpad; 1103 Py_ssize_t rpad; 1104 Py_ssize_t total; 1105 1106 #if STRINGLIB_IS_UNICODE 1107 Py_UNICODE *re_unicode_tmp = NULL; 1108 Py_UNICODE *im_unicode_tmp = NULL; 1109 #endif 1110 1111 /* Locale settings, either from the actual locale or 1112 from a hard-code pseudo-locale */ 1113 LocaleInfo locale; 1114 1115 if (format->precision > INT_MAX) { 1116 PyErr_SetString(PyExc_ValueError, "precision too big"); 1117 goto done; 1118 } 1119 precision = (int)format->precision; 1120 1121 /* Alternate is not allowed on complex. */ 1122 if (format->alternate) { 1123 PyErr_SetString(PyExc_ValueError, 1124 "Alternate form (#) not allowed in complex format " 1125 "specifier"); 1126 goto done; 1127 } 1128 1129 /* Neither is zero pading. */ 1130 if (format->fill_char == '0') { 1131 PyErr_SetString(PyExc_ValueError, 1132 "Zero padding is not allowed in complex format " 1133 "specifier"); 1134 goto done; 1135 } 1136 1137 /* Neither is '=' alignment . */ 1138 if (format->align == '=') { 1139 PyErr_SetString(PyExc_ValueError, 1140 "'=' alignment flag is not allowed in complex format " 1141 "specifier"); 1142 goto done; 1143 } 1144 1145 re = PyComplex_RealAsDouble(value); 1146 if (re == -1.0 && PyErr_Occurred()) 1147 goto done; 1148 im = PyComplex_ImagAsDouble(value); 1149 if (im == -1.0 && PyErr_Occurred()) 1150 goto done; 1151 1152 if (type == '\0') { 1153 /* Omitted type specifier. Should be like str(self). */ 1154 type = 'g'; 1155 default_precision = PyFloat_STR_PRECISION; 1156 if (re == 0.0 && copysign(1.0, re) == 1.0) 1157 skip_re = 1; 1158 else 1159 add_parens = 1; 1160 } 1161 1162 if (type == 'n') 1163 /* 'n' is the same as 'g', except for the locale used to 1164 format the result. We take care of that later. */ 1165 type = 'g'; 1166 1167 if (precision < 0) 1168 precision = default_precision; 1169 1170 /* Cast "type", because if we're in unicode we need to pass a 1171 8-bit char. This is safe, because we've restricted what "type" 1172 can be. */ 1173 re_buf = PyOS_double_to_string(re, (char)type, precision, flags, 1174 &re_float_type); 1175 if (re_buf == NULL) 1176 goto done; 1177 im_buf = PyOS_double_to_string(im, (char)type, precision, flags, 1178 &im_float_type); 1179 if (im_buf == NULL) 1180 goto done; 1181 1182 n_re_digits = strlen(re_buf); 1183 n_im_digits = strlen(im_buf); 1184 1185 /* Since there is no unicode version of PyOS_double_to_string, 1186 just use the 8 bit version and then convert to unicode. */ 1187 #if STRINGLIB_IS_UNICODE 1188 re_unicode_tmp = (Py_UNICODE*)PyMem_Malloc((n_re_digits)*sizeof(Py_UNICODE)); 1189 if (re_unicode_tmp == NULL) { 1190 PyErr_NoMemory(); 1191 goto done; 1192 } 1193 strtounicode(re_unicode_tmp, re_buf, n_re_digits); 1194 p_re = re_unicode_tmp; 1195 1196 im_unicode_tmp = (Py_UNICODE*)PyMem_Malloc((n_im_digits)*sizeof(Py_UNICODE)); 1197 if (im_unicode_tmp == NULL) { 1198 PyErr_NoMemory(); 1199 goto done; 1200 } 1201 strtounicode(im_unicode_tmp, im_buf, n_im_digits); 1202 p_im = im_unicode_tmp; 1203 #else 1204 p_re = re_buf; 1205 p_im = im_buf; 1206 #endif 1207 1208 /* Is a sign character present in the output? If so, remember it 1209 and skip it */ 1210 if (*p_re == '-') { 1211 re_sign_char = *p_re; 1212 ++p_re; 1213 --n_re_digits; 1214 } 1215 if (*p_im == '-') { 1216 im_sign_char = *p_im; 1217 ++p_im; 1218 --n_im_digits; 1219 } 1220 1221 /* Determine if we have any "remainder" (after the digits, might include 1222 decimal or exponent or both (or neither)) */ 1223 parse_number(p_re, n_re_digits, &n_re_remainder, &re_has_decimal); 1224 parse_number(p_im, n_im_digits, &n_im_remainder, &im_has_decimal); 1225 1226 /* Determine the grouping, separator, and decimal point, if any. */ 1227 get_locale_info(format->type == 'n' ? LT_CURRENT_LOCALE : 1228 (format->thousands_separators ? 1229 LT_DEFAULT_LOCALE : 1230 LT_NO_LOCALE), 1231 &locale); 1232 1233 /* Turn off any padding. We'll do it later after we've composed 1234 the numbers without padding. */ 1235 tmp_format.fill_char = '\0'; 1236 tmp_format.align = '<'; 1237 tmp_format.width = -1; 1238 1239 /* Calculate how much memory we'll need. */ 1240 n_re_total = calc_number_widths(&re_spec, 0, re_sign_char, p_re, 1241 n_re_digits, n_re_remainder, 1242 re_has_decimal, &locale, &tmp_format); 1243 1244 /* Same formatting, but always include a sign, unless the real part is 1245 * going to be omitted, in which case we use whatever sign convention was 1246 * requested by the original format. */ 1247 if (!skip_re) 1248 tmp_format.sign = '+'; 1249 n_im_total = calc_number_widths(&im_spec, 0, im_sign_char, p_im, 1250 n_im_digits, n_im_remainder, 1251 im_has_decimal, &locale, &tmp_format); 1252 1253 if (skip_re) 1254 n_re_total = 0; 1255 1256 /* Add 1 for the 'j', and optionally 2 for parens. */ 1257 calc_padding(n_re_total + n_im_total + 1 + add_parens * 2, 1258 format->width, format->align, &lpad, &rpad, &total); 1259 1260 result = STRINGLIB_NEW(NULL, total); 1261 if (result == NULL) 1262 goto done; 1263 1264 /* Populate the memory. First, the padding. */ 1265 p = fill_padding(STRINGLIB_STR(result), 1266 n_re_total + n_im_total + 1 + add_parens * 2, 1267 format->fill_char, lpad, rpad); 1268 1269 if (add_parens) 1270 *p++ = '('; 1271 1272 if (!skip_re) { 1273 fill_number(p, &re_spec, p_re, n_re_digits, NULL, 0, &locale, 0); 1274 p += n_re_total; 1275 } 1276 fill_number(p, &im_spec, p_im, n_im_digits, NULL, 0, &locale, 0); 1277 p += n_im_total; 1278 *p++ = 'j'; 1279 1280 if (add_parens) 1281 *p++ = ')'; 1282 1283 done: 1284 PyMem_Free(re_buf); 1285 PyMem_Free(im_buf); 1286 #if STRINGLIB_IS_UNICODE 1287 PyMem_Free(re_unicode_tmp); 1288 PyMem_Free(im_unicode_tmp); 1289 #endif 1290 return result; 1291 } 1292 #endif /* FORMAT_COMPLEX */ 1293 1294 /************************************************************************/ 1295 /*********** built in formatters ****************************************/ 1296 /************************************************************************/ 1297 PyObject * 1298 FORMAT_STRING(PyObject *obj, 1299 STRINGLIB_CHAR *format_spec, 1300 Py_ssize_t format_spec_len) 1301 { 1302 InternalFormatSpec format; 1303 PyObject *result = NULL; 1304 1305 /* check for the special case of zero length format spec, make 1306 it equivalent to str(obj) */ 1307 if (format_spec_len == 0) { 1308 result = STRINGLIB_TOSTR(obj); 1309 goto done; 1310 } 1311 1312 /* parse the format_spec */ 1313 if (!parse_internal_render_format_spec(format_spec, format_spec_len, 1314 &format, 's', '<')) 1315 goto done; 1316 1317 /* type conversion? */ 1318 switch (format.type) { 1319 case 's': 1320 /* no type conversion needed, already a string. do the formatting */ 1321 result = format_string_internal(obj, &format); 1322 break; 1323 default: 1324 /* unknown */ 1325 unknown_presentation_type(format.type, obj->ob_type->tp_name); 1326 goto done; 1327 } 1328 1329 done: 1330 return result; 1331 } 1332 1333 #if defined FORMAT_LONG || defined FORMAT_INT 1334 static PyObject* 1335 format_int_or_long(PyObject* obj, 1336 STRINGLIB_CHAR *format_spec, 1337 Py_ssize_t format_spec_len, 1338 IntOrLongToString tostring) 1339 { 1340 PyObject *result = NULL; 1341 PyObject *tmp = NULL; 1342 InternalFormatSpec format; 1343 1344 /* check for the special case of zero length format spec, make 1345 it equivalent to str(obj) */ 1346 if (format_spec_len == 0) { 1347 result = STRINGLIB_TOSTR(obj); 1348 goto done; 1349 } 1350 1351 /* parse the format_spec */ 1352 if (!parse_internal_render_format_spec(format_spec, 1353 format_spec_len, 1354 &format, 'd', '>')) 1355 goto done; 1356 1357 /* type conversion? */ 1358 switch (format.type) { 1359 case 'b': 1360 case 'c': 1361 case 'd': 1362 case 'o': 1363 case 'x': 1364 case 'X': 1365 case 'n': 1366 /* no type conversion needed, already an int (or long). do 1367 the formatting */ 1368 result = format_int_or_long_internal(obj, &format, tostring); 1369 break; 1370 1371 case 'e': 1372 case 'E': 1373 case 'f': 1374 case 'F': 1375 case 'g': 1376 case 'G': 1377 case '%': 1378 /* convert to float */ 1379 tmp = PyNumber_Float(obj); 1380 if (tmp == NULL) 1381 goto done; 1382 result = format_float_internal(tmp, &format); 1383 break; 1384 1385 default: 1386 /* unknown */ 1387 unknown_presentation_type(format.type, obj->ob_type->tp_name); 1388 goto done; 1389 } 1390 1391 done: 1392 Py_XDECREF(tmp); 1393 return result; 1394 } 1395 #endif /* FORMAT_LONG || defined FORMAT_INT */ 1396 1397 #ifdef FORMAT_LONG 1398 /* Need to define long_format as a function that will convert a long 1399 to a string. In 3.0, _PyLong_Format has the correct signature. In 1400 2.x, we need to fudge a few parameters */ 1401 #if PY_VERSION_HEX >= 0x03000000 1402 #define long_format _PyLong_Format 1403 #else 1404 static PyObject* 1405 long_format(PyObject* value, int base) 1406 { 1407 /* Convert to base, don't add trailing 'L', and use the new octal 1408 format. We already know this is a long object */ 1409 assert(PyLong_Check(value)); 1410 /* convert to base, don't add 'L', and use the new octal format */ 1411 return _PyLong_Format(value, base, 0, 1); 1412 } 1413 #endif 1414 1415 PyObject * 1416 FORMAT_LONG(PyObject *obj, 1417 STRINGLIB_CHAR *format_spec, 1418 Py_ssize_t format_spec_len) 1419 { 1420 return format_int_or_long(obj, format_spec, format_spec_len, 1421 long_format); 1422 } 1423 #endif /* FORMAT_LONG */ 1424 1425 #ifdef FORMAT_INT 1426 /* this is only used for 2.x, not 3.0 */ 1427 static PyObject* 1428 int_format(PyObject* value, int base) 1429 { 1430 /* Convert to base, and use the new octal format. We already 1431 know this is an int object */ 1432 assert(PyInt_Check(value)); 1433 return _PyInt_Format((PyIntObject*)value, base, 1); 1434 } 1435 1436 PyObject * 1437 FORMAT_INT(PyObject *obj, 1438 STRINGLIB_CHAR *format_spec, 1439 Py_ssize_t format_spec_len) 1440 { 1441 return format_int_or_long(obj, format_spec, format_spec_len, 1442 int_format); 1443 } 1444 #endif /* FORMAT_INT */ 1445 1446 #ifdef FORMAT_FLOAT 1447 PyObject * 1448 FORMAT_FLOAT(PyObject *obj, 1449 STRINGLIB_CHAR *format_spec, 1450 Py_ssize_t format_spec_len) 1451 { 1452 PyObject *result = NULL; 1453 InternalFormatSpec format; 1454 1455 /* check for the special case of zero length format spec, make 1456 it equivalent to str(obj) */ 1457 if (format_spec_len == 0) { 1458 result = STRINGLIB_TOSTR(obj); 1459 goto done; 1460 } 1461 1462 /* parse the format_spec */ 1463 if (!parse_internal_render_format_spec(format_spec, 1464 format_spec_len, 1465 &format, '\0', '>')) 1466 goto done; 1467 1468 /* type conversion? */ 1469 switch (format.type) { 1470 case '\0': /* No format code: like 'g', but with at least one decimal. */ 1471 case 'e': 1472 case 'E': 1473 case 'f': 1474 case 'F': 1475 case 'g': 1476 case 'G': 1477 case 'n': 1478 case '%': 1479 /* no conversion, already a float. do the formatting */ 1480 result = format_float_internal(obj, &format); 1481 break; 1482 1483 default: 1484 /* unknown */ 1485 unknown_presentation_type(format.type, obj->ob_type->tp_name); 1486 goto done; 1487 } 1488 1489 done: 1490 return result; 1491 } 1492 #endif /* FORMAT_FLOAT */ 1493 1494 #ifdef FORMAT_COMPLEX 1495 PyObject * 1496 FORMAT_COMPLEX(PyObject *obj, 1497 STRINGLIB_CHAR *format_spec, 1498 Py_ssize_t format_spec_len) 1499 { 1500 PyObject *result = NULL; 1501 InternalFormatSpec format; 1502 1503 /* check for the special case of zero length format spec, make 1504 it equivalent to str(obj) */ 1505 if (format_spec_len == 0) { 1506 result = STRINGLIB_TOSTR(obj); 1507 goto done; 1508 } 1509 1510 /* parse the format_spec */ 1511 if (!parse_internal_render_format_spec(format_spec, 1512 format_spec_len, 1513 &format, '\0', '>')) 1514 goto done; 1515 1516 /* type conversion? */ 1517 switch (format.type) { 1518 case '\0': /* No format code: like 'g', but with at least one decimal. */ 1519 case 'e': 1520 case 'E': 1521 case 'f': 1522 case 'F': 1523 case 'g': 1524 case 'G': 1525 case 'n': 1526 /* no conversion, already a complex. do the formatting */ 1527 result = format_complex_internal(obj, &format); 1528 break; 1529 1530 default: 1531 /* unknown */ 1532 unknown_presentation_type(format.type, obj->ob_type->tp_name); 1533 goto done; 1534 } 1535 1536 done: 1537 return result; 1538 } 1539 #endif /* FORMAT_COMPLEX */ 1540
