Objects/stringlib/formatter.h

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