Ignore:
Timestamp:
Mar 19, 2014, 11:31:01 PM (11 years ago)
Author:
dmik
Message:

python: Merge vendor 2.7.6 to trunk.

Location:
python/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • python/trunk

  • python/trunk/Objects/stringlib/formatter.h

    r2 r391  
    11/* implements the string, long, and float formatters.  that is,
    22   string.__format__, etc. */
     3
     4#include <locale.h>
    35
    46/* Before including this, you must include either:
     
    1012   FORMAT_LONG
    1113   FORMAT_FLOAT
     14   FORMAT_COMPLEX
    1215   to be whatever you want the public names of these functions to
    1316   be.  These are the only non-static functions defined here.
    1417*/
    15 
    16 #define ALLOW_PARENS_FOR_SIGN 0
    1718
    1819/* Raises an exception about an unknown presentation type for this
     
    4445}
    4546
     47static void
     48invalid_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
    4665/*
    4766    get_integer consumes 0 or more decimal digit characters from an
     
    5574                  Py_ssize_t *result)
    5675{
    57     Py_ssize_t accumulator, digitval, oldaccumulator;
     76    Py_ssize_t accumulator, digitval;
    5877    int numdigits;
    5978    accumulator = numdigits = 0;
     
    6584            break;
    6685        /*
    67            This trick was copied from old Unicode format code.  It's cute,
    68            but would really suck on an old machine with a slow divide
    69            implementation.  Fortunately, in the normal case we do not
    70            expect too many digits.
     86           Detect possible overflow before it happens:
     87
     88              accumulator * 10 + digitval > PY_SSIZE_T_MAX if and only if
     89              accumulator > (PY_SSIZE_T_MAX - digitval) / 10.
    7190        */
    72         oldaccumulator = accumulator;
    73         accumulator *= 10;
    74         if ((accumulator+10)/10 != oldaccumulator+1) {
     91        if (accumulator > (PY_SSIZE_T_MAX - digitval) / 10) {
    7592            PyErr_Format(PyExc_ValueError,
    7693                         "Too many decimal digits in format string");
    7794            return -1;
    7895        }
    79         accumulator += digitval;
     96        accumulator = accumulator * 10 + digitval;
    8097    }
    8198    *result = accumulator;
     
    105122    switch (c) {
    106123    case ' ': case '+': case '-':
    107 #if ALLOW_PARENS_FOR_SIGN
    108     case '(':
    109 #endif
    110124        return 1;
    111125    default:
     
    121135    STRINGLIB_CHAR sign;
    122136    Py_ssize_t width;
     137    int thousands_separators;
    123138    Py_ssize_t precision;
    124139    STRINGLIB_CHAR type;
    125140} InternalFormatSpec;
     141
     142
     143#if 0
     144/* Occassionally useful for debugging. Should normally be commented out. */
     145static void
     146DEBUG_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
    126161
    127162/*
     
    133168static int
    134169parse_internal_render_format_spec(STRINGLIB_CHAR *format_spec,
    135                                   Py_ssize_t format_spec_len,
     170                                  Py_ssize_t format_spec_len,
    136171                                  InternalFormatSpec *format,
    137                                   char default_type)
     172                                  char default_type,
     173                                  char default_align)
    138174{
    139175    STRINGLIB_CHAR *ptr = format_spec;
     
    143179       the input string */
    144180
    145     Py_ssize_t specified_width;
     181    Py_ssize_t consumed;
     182    int align_specified = 0;
    146183
    147184    format->fill_char = '\0';
    148     format->align = '\0';
     185    format->align = default_align;
    149186    format->alternate = 0;
    150187    format->sign = '\0';
    151188    format->width = -1;
     189    format->thousands_separators = 0;
    152190    format->precision = -1;
    153191    format->type = default_type;
     
    158196        format->align = ptr[1];
    159197        format->fill_char = ptr[0];
     198        align_specified = 1;
    160199        ptr += 2;
    161200    }
    162201    else if (end-ptr >= 1 && is_alignment_token(ptr[0])) {
    163202        format->align = ptr[0];
     203        align_specified = 1;
    164204        ++ptr;
    165205    }
     
    169209        format->sign = ptr[0];
    170210        ++ptr;
    171 #if ALLOW_PARENS_FOR_SIGN
    172         if (end-ptr >= 1 && ptr[0] == ')') {
    173             ++ptr;
    174         }
    175 #endif
    176211    }
    177212
     
    179214       applies to integers. */
    180215    if (end-ptr >= 1 && ptr[0] == '#') {
    181         format->alternate = 1;
    182         ++ptr;
     216        format->alternate = 1;
     217        ++ptr;
    183218    }
    184219
     
    186221    if (format->fill_char == '\0' && end-ptr >= 1 && ptr[0] == '0') {
    187222        format->fill_char = '0';
    188         if (format->align == '\0') {
     223        if (!align_specified) {
    189224            format->align = '=';
    190225        }
     
    192227    }
    193228
    194     /* XXX add error checking */
    195     specified_width = get_integer(&ptr, end, &format->width);
    196 
    197     /* if specified_width is 0, we didn't consume any characters for
    198        the width. in that case, reset the width to -1, because
    199        get_integer() will have set it to zero */
    200     if (specified_width == 0) {
     229    consumed = get_integer(&ptr, end, &format->width);
     230    if (consumed == -1)
     231        /* Overflow error. Exception already set. */
     232        return 0;
     233
     234    /* If consumed is 0, we didn't consume any characters for the
     235       width. In that case, reset the width to -1, because
     236       get_integer() will have set it to zero. -1 is how we record
     237       that the width wasn't specified. */
     238    if (consumed == 0)
    201239        format->width = -1;
     240
     241    /* Comma signifies add thousands separators */
     242    if (end-ptr && ptr[0] == ',') {
     243        format->thousands_separators = 1;
     244        ++ptr;
    202245    }
    203246
     
    206249        ++ptr;
    207250
    208         /* XXX add error checking */
    209         specified_width = get_integer(&ptr, end, &format->precision);
    210 
    211         /* not having a precision after a dot is an error */
    212         if (specified_width == 0) {
     251        consumed = get_integer(&ptr, end, &format->precision);
     252        if (consumed == -1)
     253            /* Overflow error. Exception already set. */
     254            return 0;
     255
     256        /* Not having a precision after a dot is an error. */
     257        if (consumed == 0) {
    213258            PyErr_Format(PyExc_ValueError,
    214259                         "Format specifier missing precision");
     
    218263    }
    219264
    220     /* Finally, parse the type field */
     265    /* Finally, parse the type field. */
    221266
    222267    if (end-ptr > 1) {
    223         /* invalid conversion spec */
     268        /* More than one char remain, invalid conversion spec. */
    224269        PyErr_Format(PyExc_ValueError, "Invalid conversion specification");
    225270        return 0;
     
    231276    }
    232277
     278    /* Do as much validating as we can, just by looking at the format
     279       specifier.  Do not take into account what type of formatting
     280       we're doing (int, float, string). */
     281
     282    if (format->thousands_separators) {
     283        switch (format->type) {
     284        case 'd':
     285        case 'e':
     286        case 'f':
     287        case 'g':
     288        case 'E':
     289        case 'G':
     290        case '%':
     291        case 'F':
     292        case '\0':
     293            /* These are allowed. See PEP 378.*/
     294            break;
     295        default:
     296            invalid_comma_type(format->type);
     297            return 0;
     298        }
     299    }
     300
    233301    return 1;
    234302}
    235303
    236 #if defined FORMAT_FLOAT || defined FORMAT_LONG
     304/* Calculate the padding needed. */
     305static void
     306calc_padding(Py_ssize_t nchars, Py_ssize_t width, STRINGLIB_CHAR align,
     307             Py_ssize_t *n_lpadding, Py_ssize_t *n_rpadding,
     308             Py_ssize_t *n_total)
     309{
     310    if (width >= 0) {
     311        if (nchars > width)
     312            *n_total = nchars;
     313        else
     314            *n_total = width;
     315    }
     316    else {
     317        /* not specified, use all of the chars and no more */
     318        *n_total = nchars;
     319    }
     320
     321    /* Figure out how much leading space we need, based on the
     322       aligning */
     323    if (align == '>')
     324        *n_lpadding = *n_total - nchars;
     325    else if (align == '^')
     326        *n_lpadding = (*n_total - nchars) / 2;
     327    else if (align == '<' || align == '=')
     328        *n_lpadding = 0;
     329    else {
     330        /* We should never have an unspecified alignment. */
     331        *n_lpadding = 0;
     332        assert(0);
     333    }
     334
     335    *n_rpadding = *n_total - nchars - *n_lpadding;
     336}
     337
     338/* Do the padding, and return a pointer to where the caller-supplied
     339   content goes. */
     340static STRINGLIB_CHAR *
     341fill_padding(STRINGLIB_CHAR *p, Py_ssize_t nchars, STRINGLIB_CHAR fill_char,
     342             Py_ssize_t n_lpadding, Py_ssize_t n_rpadding)
     343{
     344    /* Pad on left. */
     345    if (n_lpadding)
     346        STRINGLIB_FILL(p, fill_char, n_lpadding);
     347
     348    /* Pad on right. */
     349    if (n_rpadding)
     350        STRINGLIB_FILL(p + nchars + n_lpadding, fill_char, n_rpadding);
     351
     352    /* Pointer to the user content. */
     353    return p + n_lpadding;
     354}
     355
     356#if defined FORMAT_FLOAT || defined FORMAT_LONG || defined FORMAT_COMPLEX
    237357/************************************************************************/
    238358/*********** common routines for numeric formatting *********************/
    239359/************************************************************************/
     360
     361/* Locale type codes. */
     362#define LT_CURRENT_LOCALE 0
     363#define LT_DEFAULT_LOCALE 1
     364#define LT_NO_LOCALE 2
     365
     366/* Locale info needed for formatting integers and the part of floats
     367   before and including the decimal. Note that locales only support
     368   8-bit chars, not unicode. */
     369typedef struct {
     370    char *decimal_point;
     371    char *thousands_sep;
     372    char *grouping;
     373} LocaleInfo;
    240374
    241375/* describes the layout for an integer, see the comment in
     
    246380    Py_ssize_t n_spadding;
    247381    Py_ssize_t n_rpadding;
    248     char lsign;
    249     Py_ssize_t n_lsign;
    250     char rsign;
    251     Py_ssize_t n_rsign;
    252     Py_ssize_t n_total; /* just a convenience, it's derivable from the
    253                            other fields */
     382    char sign;
     383    Py_ssize_t n_sign;      /* number of digits needed for sign (0/1) */
     384    Py_ssize_t n_grouped_digits; /* Space taken up by the digits, including
     385                                    any grouping chars. */
     386    Py_ssize_t n_decimal;   /* 0 if only an integer */
     387    Py_ssize_t n_remainder; /* Digits in decimal and/or exponent part,
     388                               excluding the decimal itself, if
     389                               present. */
     390
     391    /* These 2 are not the widths of fields, but are needed by
     392       STRINGLIB_GROUPING. */
     393    Py_ssize_t n_digits;    /* The number of digits before a decimal
     394                               or exponent. */
     395    Py_ssize_t n_min_width; /* The min_width we used when we computed
     396                               the n_grouped_digits width. */
    254397} NumberFieldWidths;
     398
     399
     400/* Given a number of the form:
     401   digits[remainder]
     402   where ptr points to the start and end points to the end, find where
     403    the integer part ends. This could be a decimal, an exponent, both,
     404    or neither.
     405   If a decimal point is present, set *has_decimal and increment
     406    remainder beyond it.
     407   Results are undefined (but shouldn't crash) for improperly
     408    formatted strings.
     409*/
     410static void
     411parse_number(STRINGLIB_CHAR *ptr, Py_ssize_t len,
     412             Py_ssize_t *n_remainder, int *has_decimal)
     413{
     414    STRINGLIB_CHAR *end = ptr + len;
     415    STRINGLIB_CHAR *remainder;
     416
     417    while (ptr<end && isdigit(*ptr))
     418        ++ptr;
     419    remainder = ptr;
     420
     421    /* Does remainder start with a decimal point? */
     422    *has_decimal = ptr<end && *remainder == '.';
     423
     424    /* Skip the decimal point. */
     425    if (*has_decimal)
     426        remainder++;
     427
     428    *n_remainder = end - remainder;
     429}
    255430
    256431/* not all fields of format are used.  for example, precision is
     
    258433   about what it does?  or is passing a single format parameter easier
    259434   and more efficient enough to justify a little obfuscation? */
    260 static void
    261 calc_number_widths(NumberFieldWidths *spec, STRINGLIB_CHAR actual_sign,
    262                    Py_ssize_t n_prefix, Py_ssize_t n_digits,
    263                    const InternalFormatSpec *format)
    264 {
     435static Py_ssize_t
     436calc_number_widths(NumberFieldWidths *spec, Py_ssize_t n_prefix,
     437                   STRINGLIB_CHAR sign_char, STRINGLIB_CHAR *number,
     438                   Py_ssize_t n_number, Py_ssize_t n_remainder,
     439                   int has_decimal, const LocaleInfo *locale,
     440                   const InternalFormatSpec *format)
     441{
     442    Py_ssize_t n_non_digit_non_padding;
     443    Py_ssize_t n_padding;
     444
     445    spec->n_digits = n_number - n_remainder - (has_decimal?1:0);
    265446    spec->n_lpadding = 0;
    266     spec->n_prefix = 0;
     447    spec->n_prefix = n_prefix;
     448    spec->n_decimal = has_decimal ? strlen(locale->decimal_point) : 0;
     449    spec->n_remainder = n_remainder;
    267450    spec->n_spadding = 0;
    268451    spec->n_rpadding = 0;
    269     spec->lsign = '\0';
    270     spec->n_lsign = 0;
    271     spec->rsign = '\0';
    272     spec->n_rsign = 0;
     452    spec->sign = '\0';
     453    spec->n_sign = 0;
    273454
    274455    /* the output will look like:
    275        |                                                                    |
    276        | <lpadding> <lsign> <prefix> <spadding> <digits> <rsign> <rpadding> |
    277        |                                                                    |
    278 
    279        lsign and rsign are computed from format->sign and the actual
     456       |                                                                                         |
     457       | <lpadding> <sign> <prefix> <spadding> <grouped_digits> <decimal> <remainder> <rpadding> |
     458       |                                                                                         |
     459
     460       sign is computed from format->sign and the actual
    280461       sign of the number
    281462
     
    292473
    293474    /* compute the various parts we're going to write */
    294     if (format->sign == '+') {
     475    switch (format->sign) {
     476    case '+':
    295477        /* always put a + or - */
    296         spec->n_lsign = 1;
    297         spec->lsign = (actual_sign == '-' ? '-' : '+');
    298     }
    299 #if ALLOW_PARENS_FOR_SIGN
    300     else if (format->sign == '(') {
    301         if (actual_sign == '-') {
    302             spec->n_lsign = 1;
    303             spec->lsign = '(';
    304             spec->n_rsign = 1;
    305             spec->rsign = ')';
     478        spec->n_sign = 1;
     479        spec->sign = (sign_char == '-' ? '-' : '+');
     480        break;
     481    case ' ':
     482        spec->n_sign = 1;
     483        spec->sign = (sign_char == '-' ? '-' : ' ');
     484        break;
     485    default:
     486        /* Not specified, or the default (-) */
     487        if (sign_char == '-') {
     488            spec->n_sign = 1;
     489            spec->sign = '-';
    306490        }
    307491    }
    308 #endif
    309     else if (format->sign == ' ') {
    310         spec->n_lsign = 1;
    311         spec->lsign = (actual_sign == '-' ? '-' : ' ');
    312     }
    313     else {
    314         /* non specified, or the default (-) */
    315         if (actual_sign == '-') {
    316             spec->n_lsign = 1;
    317             spec->lsign = '-';
     492
     493    /* The number of chars used for non-digits and non-padding. */
     494    n_non_digit_non_padding = spec->n_sign + spec->n_prefix + spec->n_decimal +
     495        spec->n_remainder;
     496
     497    /* min_width can go negative, that's okay. format->width == -1 means
     498       we don't care. */
     499    if (format->fill_char == '0' && format->align == '=')
     500        spec->n_min_width = format->width - n_non_digit_non_padding;
     501    else
     502        spec->n_min_width = 0;
     503
     504    if (spec->n_digits == 0)
     505        /* This case only occurs when using 'c' formatting, we need
     506           to special case it because the grouping code always wants
     507           to have at least one character. */
     508        spec->n_grouped_digits = 0;
     509    else
     510        spec->n_grouped_digits = STRINGLIB_GROUPING(NULL, 0, NULL,
     511                                                    spec->n_digits,
     512                                                    spec->n_min_width,
     513                                                    locale->grouping,
     514                                                    locale->thousands_sep);
     515
     516    /* Given the desired width and the total of digit and non-digit
     517       space we consume, see if we need any padding. format->width can
     518       be negative (meaning no padding), but this code still works in
     519       that case. */
     520    n_padding = format->width -
     521                        (n_non_digit_non_padding + spec->n_grouped_digits);
     522    if (n_padding > 0) {
     523        /* Some padding is needed. Determine if it's left, space, or right. */
     524        switch (format->align) {
     525        case '<':
     526            spec->n_rpadding = n_padding;
     527            break;
     528        case '^':
     529            spec->n_lpadding = n_padding / 2;
     530            spec->n_rpadding = n_padding - spec->n_lpadding;
     531            break;
     532        case '=':
     533            spec->n_spadding = n_padding;
     534            break;
     535        case '>':
     536            spec->n_lpadding = n_padding;
     537            break;
     538        default:
     539            /* Shouldn't get here, but treat it as '>' */
     540            spec->n_lpadding = n_padding;
     541            assert(0);
     542            break;
    318543        }
    319544    }
    320 
    321     spec->n_prefix = n_prefix;
    322 
    323     /* now the number of padding characters */
    324     if (format->width == -1) {
    325         /* no padding at all, nothing to do */
    326     }
    327     else {
    328         /* see if any padding is needed */
    329         if (spec->n_lsign + n_digits + spec->n_rsign +
    330                 spec->n_prefix >= format->width) {
    331             /* no padding needed, we're already bigger than the
    332                requested width */
     545    return spec->n_lpadding + spec->n_sign + spec->n_prefix +
     546        spec->n_spadding + spec->n_grouped_digits + spec->n_decimal +
     547        spec->n_remainder + spec->n_rpadding;
     548}
     549
     550/* Fill in the digit parts of a numbers's string representation,
     551   as determined in calc_number_widths().
     552   No error checking, since we know the buffer is the correct size. */
     553static void
     554fill_number(STRINGLIB_CHAR *buf, const NumberFieldWidths *spec,
     555            STRINGLIB_CHAR *digits, Py_ssize_t n_digits,
     556            STRINGLIB_CHAR *prefix, STRINGLIB_CHAR fill_char,
     557            LocaleInfo *locale, int toupper)
     558{
     559    /* Used to keep track of digits, decimal, and remainder. */
     560    STRINGLIB_CHAR *p = digits;
     561
     562#ifndef NDEBUG
     563    Py_ssize_t r;
     564#endif
     565
     566    if (spec->n_lpadding) {
     567        STRINGLIB_FILL(buf, fill_char, spec->n_lpadding);
     568        buf += spec->n_lpadding;
     569    }
     570    if (spec->n_sign == 1) {
     571        *buf++ = spec->sign;
     572    }
     573    if (spec->n_prefix) {
     574        memmove(buf,
     575                prefix,
     576                spec->n_prefix * sizeof(STRINGLIB_CHAR));
     577        if (toupper) {
     578            Py_ssize_t t;
     579            for (t = 0; t < spec->n_prefix; ++t)
     580                buf[t] = STRINGLIB_TOUPPER(buf[t]);
    333581        }
    334         else {
    335             /* determine which of left, space, or right padding is
    336                needed */
    337             Py_ssize_t padding = format->width -
    338                                     (spec->n_lsign + spec->n_prefix +
    339                                      n_digits + spec->n_rsign);
    340             if (format->align == '<')
    341                 spec->n_rpadding = padding;
    342             else if (format->align == '>')
    343                 spec->n_lpadding = padding;
    344             else if (format->align == '^') {
    345                 spec->n_lpadding = padding / 2;
    346                 spec->n_rpadding = padding - spec->n_lpadding;
    347             }
    348             else if (format->align == '=')
    349                 spec->n_spadding = padding;
    350             else
    351                 spec->n_lpadding = padding;
    352         }
    353     }
    354     spec->n_total = spec->n_lpadding + spec->n_lsign + spec->n_prefix +
    355             spec->n_spadding + n_digits + spec->n_rsign + spec->n_rpadding;
    356 }
    357 
    358 /* fill in the non-digit parts of a numbers's string representation,
    359    as determined in calc_number_widths().  returns the pointer to
    360    where the digits go. */
    361 static STRINGLIB_CHAR *
    362 fill_non_digits(STRINGLIB_CHAR *p_buf, const NumberFieldWidths *spec,
    363                 STRINGLIB_CHAR *prefix, Py_ssize_t n_digits,
    364                 STRINGLIB_CHAR fill_char)
    365 {
    366     STRINGLIB_CHAR *p_digits;
    367 
    368     if (spec->n_lpadding) {
    369         STRINGLIB_FILL(p_buf, fill_char, spec->n_lpadding);
    370         p_buf += spec->n_lpadding;
    371     }
    372     if (spec->n_lsign == 1) {
    373         *p_buf++ = spec->lsign;
    374     }
    375     if (spec->n_prefix) {
    376         memmove(p_buf,
    377                 prefix,
    378                 spec->n_prefix * sizeof(STRINGLIB_CHAR));
    379         p_buf += spec->n_prefix;
     582        buf += spec->n_prefix;
    380583    }
    381584    if (spec->n_spadding) {
    382         STRINGLIB_FILL(p_buf, fill_char, spec->n_spadding);
    383         p_buf += spec->n_spadding;
    384     }
    385     p_digits = p_buf;
    386     p_buf += n_digits;
    387     if (spec->n_rsign == 1) {
    388         *p_buf++ = spec->rsign;
    389     }
     585        STRINGLIB_FILL(buf, fill_char, spec->n_spadding);
     586        buf += spec->n_spadding;
     587    }
     588
     589    /* Only for type 'c' special case, it has no digits. */
     590    if (spec->n_digits != 0) {
     591        /* Fill the digits with InsertThousandsGrouping. */
     592#ifndef NDEBUG
     593        r =
     594#endif
     595            STRINGLIB_GROUPING(buf, spec->n_grouped_digits, digits,
     596                               spec->n_digits, spec->n_min_width,
     597                               locale->grouping, locale->thousands_sep);
     598#ifndef NDEBUG
     599        assert(r == spec->n_grouped_digits);
     600#endif
     601        p += spec->n_digits;
     602    }
     603    if (toupper) {
     604        Py_ssize_t t;
     605        for (t = 0; t < spec->n_grouped_digits; ++t)
     606            buf[t] = STRINGLIB_TOUPPER(buf[t]);
     607    }
     608    buf += spec->n_grouped_digits;
     609
     610    if (spec->n_decimal) {
     611        Py_ssize_t t;
     612        for (t = 0; t < spec->n_decimal; ++t)
     613            buf[t] = locale->decimal_point[t];
     614        buf += spec->n_decimal;
     615        p += 1;
     616    }
     617
     618    if (spec->n_remainder) {
     619        memcpy(buf, p, spec->n_remainder * sizeof(STRINGLIB_CHAR));
     620        buf += spec->n_remainder;
     621        p += spec->n_remainder;
     622    }
     623
    390624    if (spec->n_rpadding) {
    391         STRINGLIB_FILL(p_buf, fill_char, spec->n_rpadding);
    392         p_buf += spec->n_rpadding;
    393     }
    394     return p_digits;
    395 }
    396 #endif /* FORMAT_FLOAT || FORMAT_LONG */
     625        STRINGLIB_FILL(buf, fill_char, spec->n_rpadding);
     626        buf += spec->n_rpadding;
     627    }
     628}
     629
     630static char no_grouping[1] = {CHAR_MAX};
     631
     632/* Find the decimal point character(s?), thousands_separator(s?), and
     633   grouping description, either for the current locale if type is
     634   LT_CURRENT_LOCALE, a hard-coded locale if LT_DEFAULT_LOCALE, or
     635   none if LT_NO_LOCALE. */
     636static void
     637get_locale_info(int type, LocaleInfo *locale_info)
     638{
     639    switch (type) {
     640    case LT_CURRENT_LOCALE: {
     641        struct lconv *locale_data = localeconv();
     642        locale_info->decimal_point = locale_data->decimal_point;
     643        locale_info->thousands_sep = locale_data->thousands_sep;
     644        locale_info->grouping = locale_data->grouping;
     645        break;
     646    }
     647    case LT_DEFAULT_LOCALE:
     648        locale_info->decimal_point = ".";
     649        locale_info->thousands_sep = ",";
     650        locale_info->grouping = "\3"; /* Group every 3 characters.  The
     651                                         (implicit) trailing 0 means repeat
     652                                         infinitely. */
     653        break;
     654    case LT_NO_LOCALE:
     655        locale_info->decimal_point = ".";
     656        locale_info->thousands_sep = "";
     657        locale_info->grouping = no_grouping;
     658        break;
     659    default:
     660        assert(0);
     661    }
     662}
     663
     664#endif /* FORMAT_FLOAT || FORMAT_LONG || FORMAT_COMPLEX */
    397665
    398666/************************************************************************/
     
    403671format_string_internal(PyObject *value, const InternalFormatSpec *format)
    404672{
    405     Py_ssize_t width; /* total field width */
    406673    Py_ssize_t lpad;
    407     STRINGLIB_CHAR *dst;
    408     STRINGLIB_CHAR *src = STRINGLIB_STR(value);
     674    Py_ssize_t rpad;
     675    Py_ssize_t total;
     676    STRINGLIB_CHAR *p;
    409677    Py_ssize_t len = STRINGLIB_LEN(value);
    410678    PyObject *result = NULL;
     
    421689        PyErr_SetString(PyExc_ValueError,
    422690                        "Alternate form (#) not allowed in string format "
    423                         "specifier");
     691                        "specifier");
    424692        goto done;
    425693    }
     
    439707    }
    440708
    441     if (format->width >= 0) {
    442         width = format->width;
    443 
    444         /* but use at least len characters */
    445         if (len > width) {
    446             width = len;
    447         }
    448     }
    449     else {
    450         /* not specified, use all of the chars and no more */
    451         width = len;
    452     }
     709    calc_padding(len, format->width, format->align, &lpad, &rpad, &total);
    453710
    454711    /* allocate the resulting string */
    455     result = STRINGLIB_NEW(NULL, width);
     712    result = STRINGLIB_NEW(NULL, total);
    456713    if (result == NULL)
    457714        goto done;
    458715
    459     /* now write into that space */
    460     dst = STRINGLIB_STR(result);
    461 
    462     /* figure out how much leading space we need, based on the
    463        aligning */
    464     if (format->align == '>')
    465         lpad = width - len;
    466     else if (format->align == '^')
    467         lpad = (width - len) / 2;
    468     else
    469         lpad = 0;
    470 
    471     /* if right aligning, increment the destination allow space on the
    472        left */
    473     memcpy(dst + lpad, src, len * sizeof(STRINGLIB_CHAR));
    474 
    475     /* do any padding */
    476     if (width > len) {
    477         STRINGLIB_CHAR fill_char = format->fill_char;
    478         if (fill_char == '\0') {
    479             /* use the default, if not specified */
    480             fill_char = ' ';
    481         }
    482 
    483         /* pad on left */
    484         if (lpad)
    485             STRINGLIB_FILL(dst, fill_char, lpad);
    486 
    487         /* pad on right */
    488         if (width - len - lpad)
    489             STRINGLIB_FILL(dst + len + lpad, fill_char, width - len - lpad);
    490     }
     716    /* Write into that space. First the padding. */
     717    p = fill_padding(STRINGLIB_STR(result), len,
     718                     format->fill_char=='\0'?' ':format->fill_char,
     719                     lpad, rpad);
     720
     721    /* Then the source string. */
     722    memcpy(p, STRINGLIB_STR(value), len * sizeof(STRINGLIB_CHAR));
    491723
    492724done:
     
    505737static PyObject *
    506738format_int_or_long_internal(PyObject *value, const InternalFormatSpec *format,
    507                             IntOrLongToString tostring)
     739                            IntOrLongToString tostring)
    508740{
    509741    PyObject *result = NULL;
     
    511743    STRINGLIB_CHAR *pnumeric_chars;
    512744    STRINGLIB_CHAR numeric_char;
    513     STRINGLIB_CHAR sign = '\0';
    514     STRINGLIB_CHAR *p;
     745    STRINGLIB_CHAR sign_char = '\0';
    515746    Py_ssize_t n_digits;       /* count of digits need from the computed
    516747                                  string */
    517     Py_ssize_t n_leading_chars;
    518     Py_ssize_t n_grouping_chars = 0; /* Count of additional chars to
    519                                         allocate, used for 'n'
    520                                         formatting. */
     748    Py_ssize_t n_remainder = 0; /* Used only for 'c' formatting, which
     749                                   produces non-digits */
    521750    Py_ssize_t n_prefix = 0;   /* Count of prefix chars, (e.g., '0x') */
     751    Py_ssize_t n_total;
    522752    STRINGLIB_CHAR *prefix = NULL;
    523753    NumberFieldWidths spec;
    524754    long x;
     755
     756    /* Locale settings, either from the actual locale or
     757       from a hard-code pseudo-locale */
     758    LocaleInfo locale;
    525759
    526760    /* no precision allowed on integers */
     
    530764        goto done;
    531765    }
    532 
    533766
    534767    /* special case for character formatting */
     
    538771            PyErr_SetString(PyExc_ValueError,
    539772                            "Sign not allowed with integer"
     773                            " format specifier 'c'");
     774            goto done;
     775        }
     776
     777        /* Error to specify a comma. */
     778        if (format->thousands_separators) {
     779            PyErr_SetString(PyExc_ValueError,
     780                            "Thousands separators not allowed with integer"
    540781                            " format specifier 'c'");
    541782            goto done;
     
    563804        }
    564805#endif
    565         numeric_char = (STRINGLIB_CHAR)x;
    566         pnumeric_chars = &numeric_char;
     806        numeric_char = (STRINGLIB_CHAR)x;
     807        pnumeric_chars = &numeric_char;
    567808        n_digits = 1;
     809
     810        /* As a sort-of hack, we tell calc_number_widths that we only
     811           have "remainder" characters. calc_number_widths thinks
     812           these are characters that don't get formatted, only copied
     813           into the output string. We do this for 'c' formatting,
     814           because the characters are likely to be non-digits. */
     815        n_remainder = 1;
    568816    }
    569817    else {
    570818        int base;
    571         int leading_chars_to_skip = 0;  /* Number of characters added by
    572                                            PyNumber_ToBase that we want to
    573                                            skip over. */
     819        int leading_chars_to_skip = 0;  /* Number of characters added by
     820                                           PyNumber_ToBase that we want to
     821                                           skip over. */
    574822
    575823        /* Compute the base and how many characters will be added by
     
    578826        case 'b':
    579827            base = 2;
    580             leading_chars_to_skip = 2; /* 0b */
     828            leading_chars_to_skip = 2; /* 0b */
    581829            break;
    582830        case 'o':
    583831            base = 8;
    584             leading_chars_to_skip = 2; /* 0o */
     832            leading_chars_to_skip = 2; /* 0o */
    585833            break;
    586834        case 'x':
    587835        case 'X':
    588836            base = 16;
    589             leading_chars_to_skip = 2; /* 0x */
     837            leading_chars_to_skip = 2; /* 0x */
    590838            break;
    591839        default:  /* shouldn't be needed, but stops a compiler warning */
     
    596844        }
    597845
    598         /* The number of prefix chars is the same as the leading
    599            chars to skip */
    600         if (format->alternate)
    601             n_prefix = leading_chars_to_skip;
     846        /* The number of prefix chars is the same as the leading
     847           chars to skip */
     848        if (format->alternate)
     849            n_prefix = leading_chars_to_skip;
    602850
    603851        /* Do the hard part, converting to a string in a given base */
    604         tmp = tostring(value, base);
     852        tmp = tostring(value, base);
    605853        if (tmp == NULL)
    606854            goto done;
    607855
    608         pnumeric_chars = STRINGLIB_STR(tmp);
     856        pnumeric_chars = STRINGLIB_STR(tmp);
    609857        n_digits = STRINGLIB_LEN(tmp);
    610858
    611         prefix = pnumeric_chars;
    612 
    613         /* Remember not to modify what pnumeric_chars points to.  it
    614            might be interned.  Only modify it after we copy it into a
    615            newly allocated output buffer. */
     859        prefix = pnumeric_chars;
     860
     861        /* Remember not to modify what pnumeric_chars points to.  it
     862           might be interned.  Only modify it after we copy it into a
     863           newly allocated output buffer. */
    616864
    617865        /* Is a sign character present in the output?  If so, remember it
    618866           and skip it */
    619         sign = pnumeric_chars[0];
    620         if (sign == '-') {
    621             ++prefix;
    622             ++leading_chars_to_skip;
     867        if (pnumeric_chars[0] == '-') {
     868            sign_char = pnumeric_chars[0];
     869            ++prefix;
     870            ++leading_chars_to_skip;
    623871        }
    624872
    625         /* Skip over the leading chars (0x, 0b, etc.) */
    626         n_digits -= leading_chars_to_skip;
    627         pnumeric_chars += leading_chars_to_skip;
    628     }
    629 
    630     if (format->type == 'n')
    631             /* Compute how many additional chars we need to allocate
    632                to hold the thousands grouping. */
    633             STRINGLIB_GROUPING(NULL, n_digits, n_digits,
    634                                0, &n_grouping_chars, 0);
    635 
    636     /* Calculate the widths of the various leading and trailing parts */
    637     calc_number_widths(&spec, sign, n_prefix, n_digits + n_grouping_chars,
    638                        format);
    639 
    640     /* Allocate a new string to hold the result */
    641     result = STRINGLIB_NEW(NULL, spec.n_total);
     873        /* Skip over the leading chars (0x, 0b, etc.) */
     874        n_digits -= leading_chars_to_skip;
     875        pnumeric_chars += leading_chars_to_skip;
     876    }
     877
     878    /* Determine the grouping, separator, and decimal point, if any. */
     879    get_locale_info(format->type == 'n' ? LT_CURRENT_LOCALE :
     880                    (format->thousands_separators ?
     881                     LT_DEFAULT_LOCALE :
     882                     LT_NO_LOCALE),
     883                    &locale);
     884
     885    /* Calculate how much memory we'll need. */
     886    n_total = calc_number_widths(&spec, n_prefix, sign_char, pnumeric_chars,
     887                       n_digits, n_remainder, 0, &locale, format);
     888
     889    /* Allocate the memory. */
     890    result = STRINGLIB_NEW(NULL, n_total);
    642891    if (!result)
    643         goto done;
    644     p = STRINGLIB_STR(result);
    645 
    646     /* XXX There is too much magic here regarding the internals of
    647        spec and the location of the prefix and digits.  It would be
    648        better if calc_number_widths returned a number of logical
    649        offsets into the buffer, and those were used.  Maybe in a
    650        future code cleanup. */
    651 
    652     /* Fill in the digit parts */
    653     n_leading_chars = spec.n_lpadding + spec.n_lsign +
    654             spec.n_prefix + spec.n_spadding;
    655     memmove(p + n_leading_chars,
    656             pnumeric_chars,
    657             n_digits * sizeof(STRINGLIB_CHAR));
    658 
    659     /* If type is 'X', convert the filled in digits to uppercase */
    660     if (format->type == 'X') {
    661         Py_ssize_t t;
    662         for (t = 0; t < n_digits; ++t)
    663             p[t + n_leading_chars] = STRINGLIB_TOUPPER(p[t + n_leading_chars]);
    664     }
    665 
    666     /* Insert the grouping, if any, after the uppercasing of the digits, so
    667        we can ensure that grouping chars won't be affected. */
    668     if (n_grouping_chars) {
    669             /* We know this can't fail, since we've already
    670                reserved enough space. */
    671             STRINGLIB_CHAR *pstart = p + n_leading_chars;
    672 #ifndef NDEBUG
    673             int r =
    674 #endif
    675                 STRINGLIB_GROUPING(pstart, n_digits, n_digits,
    676                            spec.n_total+n_grouping_chars-n_leading_chars,
    677                            NULL, 0);
    678             assert(r);
    679     }
    680 
    681     /* Fill in the non-digit parts (padding, sign, etc.) */
    682     fill_non_digits(p, &spec, prefix, n_digits + n_grouping_chars,
    683                     format->fill_char == '\0' ? ' ' : format->fill_char);
    684 
    685     /* If type is 'X', uppercase the prefix.  This has to be done after the
    686        prefix is filled in by fill_non_digits */
    687     if (format->type == 'X') {
    688         Py_ssize_t t;
    689         for (t = 0; t < n_prefix; ++t)
    690             p[t + spec.n_lpadding + spec.n_lsign] =
    691                     STRINGLIB_TOUPPER(p[t + spec.n_lpadding + spec.n_lsign]);
    692     }
    693 
     892        goto done;
     893
     894    /* Populate the memory. */
     895    fill_number(STRINGLIB_STR(result), &spec, pnumeric_chars, n_digits,
     896                prefix, format->fill_char == '\0' ? ' ' : format->fill_char,
     897                &locale, format->type == 'X');
    694898
    695899done:
     
    705909#ifdef FORMAT_FLOAT
    706910#if STRINGLIB_IS_UNICODE
    707 /* taken from unicodeobject.c */
    708 static Py_ssize_t
    709 strtounicode(Py_UNICODE *buffer, const char *charbuffer)
    710 {
    711     register Py_ssize_t i;
    712     Py_ssize_t len = strlen(charbuffer);
    713     for (i = len - 1; i >= 0; --i)
    714         buffer[i] = (Py_UNICODE) charbuffer[i];
    715 
    716     return len;
    717 }
    718 #endif
    719 
    720 /* see FORMATBUFLEN in unicodeobject.c */
    721 #define FLOAT_FORMATBUFLEN 120
     911static void
     912strtounicode(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
    722919
    723920/* much of this is taken from unicodeobject.c */
    724921static PyObject *
    725922format_float_internal(PyObject *value,
    726                       const InternalFormatSpec *format)
    727 {
    728     /* fmt = '%.' + `prec` + `type` + '%%'
    729        worst case length = 2 + 10 (len of INT_MAX) + 1 + 2 = 15 (use 20)*/
    730     char fmt[20];
    731 
    732     /* taken from unicodeobject.c */
    733     /* Worst case length calc to ensure no buffer overrun:
    734 
    735        'g' formats:
    736          fmt = %#.<prec>g
    737          buf = '-' + [0-9]*prec + '.' + 'e+' + (longest exp
    738             for any double rep.)
    739          len = 1 + prec + 1 + 2 + 5 = 9 + prec
    740 
    741        'f' formats:
    742          buf = '-' + [0-9]*x + '.' + [0-9]*prec (with x < 50)
    743          len = 1 + 50 + 1 + prec = 52 + prec
    744 
    745        If prec=0 the effective precision is 1 (the leading digit is
    746        always given), therefore increase the length by one.
    747 
    748     */
    749     char charbuf[FLOAT_FORMATBUFLEN];
     923                      const InternalFormatSpec *format)
     924{
     925    char *buf = NULL;       /* buffer returned from PyOS_double_to_string */
    750926    Py_ssize_t n_digits;
    751     double x;
    752     Py_ssize_t precision = format->precision;
    753     PyObject *result = NULL;
    754     STRINGLIB_CHAR sign;
    755     char* trailing = "";
     927    Py_ssize_t n_remainder;
     928    Py_ssize_t n_total;
     929    int has_decimal;
     930    double val;
     931    Py_ssize_t precision;
     932    Py_ssize_t default_precision = 6;
     933    STRINGLIB_CHAR type = format->type;
     934    int add_pct = 0;
    756935    STRINGLIB_CHAR *p;
    757936    NumberFieldWidths spec;
    758     STRINGLIB_CHAR type = format->type;
     937    int flags = 0;
     938    PyObject *result = NULL;
     939    STRINGLIB_CHAR sign_char = '\0';
     940    int float_type; /* Used to see if we have a nan, inf, or regular float. */
    759941
    760942#if STRINGLIB_IS_UNICODE
    761     Py_UNICODE unicodebuf[FLOAT_FORMATBUFLEN];
    762 #endif
    763 
    764     /* alternate is not allowed on floats. */
     943    Py_UNICODE *unicode_tmp = NULL;
     944#endif
     945
     946    /* Locale settings, either from the actual locale or
     947       from a hard-code pseudo-locale */
     948    LocaleInfo locale;
     949
     950    if (format->precision > INT_MAX) {
     951        PyErr_SetString(PyExc_ValueError, "precision too big");
     952        goto done;
     953    }
     954    precision = (int)format->precision;
     955
     956    /* Alternate is not allowed on floats. */
    765957    if (format->alternate) {
    766958        PyErr_SetString(PyExc_ValueError,
    767959                        "Alternate form (#) not allowed in float format "
    768                         "specifier");
    769         goto done;
    770     }
    771 
    772     /* first, do the conversion as 8-bit chars, using the platform's
    773        snprintf.  then, if needed, convert to unicode. */
    774 
    775     /* 'F' is the same as 'f', per the PEP */
    776     if (type == 'F')
    777         type = 'f';
    778 
    779     x = PyFloat_AsDouble(value);
    780 
    781     if (x == -1.0 && PyErr_Occurred())
     960                        "specifier");
     961        goto done;
     962    }
     963
     964    if (type == '\0') {
     965        /* Omitted type specifier. This is like 'g' but with at least one
     966           digit after the decimal point, and different default precision.*/
     967        type = 'g';
     968        default_precision = PyFloat_STR_PRECISION;
     969        flags |= Py_DTSF_ADD_DOT_0;
     970    }
     971
     972    if (type == 'n')
     973        /* 'n' is the same as 'g', except for the locale used to
     974           format the result. We take care of that later. */
     975        type = 'g';
     976
     977    val = PyFloat_AsDouble(value);
     978    if (val == -1.0 && PyErr_Occurred())
    782979        goto done;
    783980
    784981    if (type == '%') {
    785982        type = 'f';
    786         x *= 100;
    787         trailing = "%";
     983        val *= 100;
     984        add_pct = 1;
    788985    }
    789986
    790987    if (precision < 0)
    791         precision = 6;
    792     if (type == 'f' && fabs(x) >= 1e50)
    793         type = 'g';
    794 
    795     /* cast "type", because if we're in unicode we need to pass a
    796        8-bit char.  this is safe, because we've restricted what "type"
    797        can be */
    798     PyOS_snprintf(fmt, sizeof(fmt), "%%.%" PY_FORMAT_SIZE_T "d%c", precision,
    799                   (char)type);
    800 
    801     /* do the actual formatting */
    802     PyOS_ascii_formatd(charbuf, sizeof(charbuf), fmt, x);
    803 
    804     /* adding trailing to fmt with PyOS_snprintf doesn't work, not
    805        sure why.  we'll just concatentate it here, no harm done.  we
    806        know we can't have a buffer overflow from the fmt size
    807        analysis */
    808     strcat(charbuf, trailing);
    809 
    810     /* rather than duplicate the code for snprintf for both unicode
    811        and 8 bit strings, we just use the 8 bit version and then
    812        convert to unicode in a separate code path.  that's probably
    813        the lesser of 2 evils. */
     988        precision = default_precision;
     989
     990    /* Cast "type", because if we're in unicode we need to pass a
     991       8-bit char. This is safe, because we've restricted what "type"
     992       can be. */
     993    buf = PyOS_double_to_string(val, (char)type, precision, flags,
     994                                &float_type);
     995    if (buf == NULL)
     996        goto done;
     997    n_digits = strlen(buf);
     998
     999    if (add_pct) {
     1000        /* We know that buf has a trailing zero (since we just called
     1001           strlen() on it), and we don't use that fact any more. So we
     1002           can just write over the trailing zero. */
     1003        buf[n_digits] = '%';
     1004        n_digits += 1;
     1005    }
     1006
     1007    /* Since there is no unicode version of PyOS_double_to_string,
     1008       just use the 8 bit version and then convert to unicode. */
    8141009#if STRINGLIB_IS_UNICODE
    815     n_digits = strtounicode(unicodebuf, charbuf);
    816     p = unicodebuf;
     1010    unicode_tmp = (Py_UNICODE*)PyMem_Malloc((n_digits)*sizeof(Py_UNICODE));
     1011    if (unicode_tmp == NULL) {
     1012        PyErr_NoMemory();
     1013        goto done;
     1014    }
     1015    strtounicode(unicode_tmp, buf, n_digits);
     1016    p = unicode_tmp;
    8171017#else
    818     /* compute the length.  I believe this is done because the return
    819        value from snprintf above is unreliable */
    820     n_digits = strlen(charbuf);
    821     p = charbuf;
    822 #endif
    823 
    824     /* is a sign character present in the output?  if so, remember it
     1018    p = buf;
     1019#endif
     1020
     1021    /* Is a sign character present in the output?  If so, remember it
    8251022       and skip it */
    826     sign = p[0];
    827     if (sign == '-') {
     1023    if (*p == '-') {
     1024        sign_char = *p;
    8281025        ++p;
    8291026        --n_digits;
    8301027    }
    8311028
    832     calc_number_widths(&spec, sign, 0, n_digits, format);
    833 
    834     /* allocate a string with enough space */
    835     result = STRINGLIB_NEW(NULL, spec.n_total);
     1029    /* Determine if we have any "remainder" (after the digits, might include
     1030       decimal or exponent or both (or neither)) */
     1031    parse_number(p, n_digits, &n_remainder, &has_decimal);
     1032
     1033    /* Determine the grouping, separator, and decimal point, if any. */
     1034    get_locale_info(format->type == 'n' ? LT_CURRENT_LOCALE :
     1035                    (format->thousands_separators ?
     1036                     LT_DEFAULT_LOCALE :
     1037                     LT_NO_LOCALE),
     1038                    &locale);
     1039
     1040    /* Calculate how much memory we'll need. */
     1041    n_total = calc_number_widths(&spec, 0, sign_char, p, n_digits,
     1042                                 n_remainder, has_decimal, &locale, format);
     1043
     1044    /* Allocate the memory. */
     1045    result = STRINGLIB_NEW(NULL, n_total);
    8361046    if (result == NULL)
    8371047        goto done;
    8381048
    839     /* Fill in the non-digit parts (padding, sign, etc.) */
    840     fill_non_digits(STRINGLIB_STR(result), &spec, NULL, n_digits,
    841                     format->fill_char == '\0' ? ' ' : format->fill_char);
    842 
    843     /* fill in the digit parts */
    844     memmove(STRINGLIB_STR(result) +
    845                (spec.n_lpadding + spec.n_lsign + spec.n_spadding),
    846             p,
    847             n_digits * sizeof(STRINGLIB_CHAR));
     1049    /* Populate the memory. */
     1050    fill_number(STRINGLIB_STR(result), &spec, p, n_digits, NULL,
     1051                format->fill_char == '\0' ? ' ' : format->fill_char, &locale,
     1052                0);
    8481053
    8491054done:
     1055    PyMem_Free(buf);
     1056#if STRINGLIB_IS_UNICODE
     1057    PyMem_Free(unicode_tmp);
     1058#endif
    8501059    return result;
    8511060}
    8521061#endif /* FORMAT_FLOAT */
     1062
     1063/************************************************************************/
     1064/*********** complex formatting *****************************************/
     1065/************************************************************************/
     1066
     1067#ifdef FORMAT_COMPLEX
     1068
     1069static PyObject *
     1070format_complex_internal(PyObject *value,
     1071                        const InternalFormatSpec *format)
     1072{
     1073    double re;
     1074    double im;
     1075    char *re_buf = NULL;       /* buffer returned from PyOS_double_to_string */
     1076    char *im_buf = NULL;       /* buffer returned from PyOS_double_to_string */
     1077
     1078    InternalFormatSpec tmp_format = *format;
     1079    Py_ssize_t n_re_digits;
     1080    Py_ssize_t n_im_digits;
     1081    Py_ssize_t n_re_remainder;
     1082    Py_ssize_t n_im_remainder;
     1083    Py_ssize_t n_re_total;
     1084    Py_ssize_t n_im_total;
     1085    int re_has_decimal;
     1086    int im_has_decimal;
     1087    Py_ssize_t precision;
     1088    Py_ssize_t default_precision = 6;
     1089    STRINGLIB_CHAR type = format->type;
     1090    STRINGLIB_CHAR *p_re;
     1091    STRINGLIB_CHAR *p_im;
     1092    NumberFieldWidths re_spec;
     1093    NumberFieldWidths im_spec;
     1094    int flags = 0;
     1095    PyObject *result = NULL;
     1096    STRINGLIB_CHAR *p;
     1097    STRINGLIB_CHAR re_sign_char = '\0';
     1098    STRINGLIB_CHAR im_sign_char = '\0';
     1099    int re_float_type; /* Used to see if we have a nan, inf, or regular float. */
     1100    int im_float_type;
     1101    int add_parens = 0;
     1102    int skip_re = 0;
     1103    Py_ssize_t lpad;
     1104    Py_ssize_t rpad;
     1105    Py_ssize_t total;
     1106
     1107#if STRINGLIB_IS_UNICODE
     1108    Py_UNICODE *re_unicode_tmp = NULL;
     1109    Py_UNICODE *im_unicode_tmp = NULL;
     1110#endif
     1111
     1112    /* Locale settings, either from the actual locale or
     1113       from a hard-code pseudo-locale */
     1114    LocaleInfo locale;
     1115
     1116    if (format->precision > INT_MAX) {
     1117        PyErr_SetString(PyExc_ValueError, "precision too big");
     1118        goto done;
     1119    }
     1120    precision = (int)format->precision;
     1121
     1122    /* Alternate is not allowed on complex. */
     1123    if (format->alternate) {
     1124        PyErr_SetString(PyExc_ValueError,
     1125                        "Alternate form (#) not allowed in complex format "
     1126                        "specifier");
     1127        goto done;
     1128    }
     1129
     1130    /* Neither is zero pading. */
     1131    if (format->fill_char == '0') {
     1132        PyErr_SetString(PyExc_ValueError,
     1133                        "Zero padding is not allowed in complex format "
     1134                        "specifier");
     1135        goto done;
     1136    }
     1137
     1138    /* Neither is '=' alignment . */
     1139    if (format->align == '=') {
     1140        PyErr_SetString(PyExc_ValueError,
     1141                        "'=' alignment flag is not allowed in complex format "
     1142                        "specifier");
     1143        goto done;
     1144    }
     1145
     1146    re = PyComplex_RealAsDouble(value);
     1147    if (re == -1.0 && PyErr_Occurred())
     1148        goto done;
     1149    im = PyComplex_ImagAsDouble(value);
     1150    if (im == -1.0 && PyErr_Occurred())
     1151        goto done;
     1152
     1153    if (type == '\0') {
     1154        /* Omitted type specifier. Should be like str(self). */
     1155        type = 'g';
     1156        default_precision = PyFloat_STR_PRECISION;
     1157        if (re == 0.0 && copysign(1.0, re) == 1.0)
     1158            skip_re = 1;
     1159        else
     1160            add_parens = 1;
     1161    }
     1162
     1163    if (type == 'n')
     1164        /* 'n' is the same as 'g', except for the locale used to
     1165           format the result. We take care of that later. */
     1166        type = 'g';
     1167
     1168    if (precision < 0)
     1169        precision = default_precision;
     1170
     1171    /* Cast "type", because if we're in unicode we need to pass a
     1172       8-bit char. This is safe, because we've restricted what "type"
     1173       can be. */
     1174    re_buf = PyOS_double_to_string(re, (char)type, precision, flags,
     1175                                   &re_float_type);
     1176    if (re_buf == NULL)
     1177        goto done;
     1178    im_buf = PyOS_double_to_string(im, (char)type, precision, flags,
     1179                                   &im_float_type);
     1180    if (im_buf == NULL)
     1181        goto done;
     1182
     1183    n_re_digits = strlen(re_buf);
     1184    n_im_digits = strlen(im_buf);
     1185
     1186    /* Since there is no unicode version of PyOS_double_to_string,
     1187       just use the 8 bit version and then convert to unicode. */
     1188#if STRINGLIB_IS_UNICODE
     1189    re_unicode_tmp = (Py_UNICODE*)PyMem_Malloc((n_re_digits)*sizeof(Py_UNICODE));
     1190    if (re_unicode_tmp == NULL) {
     1191        PyErr_NoMemory();
     1192        goto done;
     1193    }
     1194    strtounicode(re_unicode_tmp, re_buf, n_re_digits);
     1195    p_re = re_unicode_tmp;
     1196
     1197    im_unicode_tmp = (Py_UNICODE*)PyMem_Malloc((n_im_digits)*sizeof(Py_UNICODE));
     1198    if (im_unicode_tmp == NULL) {
     1199        PyErr_NoMemory();
     1200        goto done;
     1201    }
     1202    strtounicode(im_unicode_tmp, im_buf, n_im_digits);
     1203    p_im = im_unicode_tmp;
     1204#else
     1205    p_re = re_buf;
     1206    p_im = im_buf;
     1207#endif
     1208
     1209    /* Is a sign character present in the output?  If so, remember it
     1210       and skip it */
     1211    if (*p_re == '-') {
     1212        re_sign_char = *p_re;
     1213        ++p_re;
     1214        --n_re_digits;
     1215    }
     1216    if (*p_im == '-') {
     1217        im_sign_char = *p_im;
     1218        ++p_im;
     1219        --n_im_digits;
     1220    }
     1221
     1222    /* Determine if we have any "remainder" (after the digits, might include
     1223       decimal or exponent or both (or neither)) */
     1224    parse_number(p_re, n_re_digits, &n_re_remainder, &re_has_decimal);
     1225    parse_number(p_im, n_im_digits, &n_im_remainder, &im_has_decimal);
     1226
     1227    /* Determine the grouping, separator, and decimal point, if any. */
     1228    get_locale_info(format->type == 'n' ? LT_CURRENT_LOCALE :
     1229                    (format->thousands_separators ?
     1230                     LT_DEFAULT_LOCALE :
     1231                     LT_NO_LOCALE),
     1232                    &locale);
     1233
     1234    /* Turn off any padding. We'll do it later after we've composed
     1235       the numbers without padding. */
     1236    tmp_format.fill_char = '\0';
     1237    tmp_format.align = '<';
     1238    tmp_format.width = -1;
     1239
     1240    /* Calculate how much memory we'll need. */
     1241    n_re_total = calc_number_widths(&re_spec, 0, re_sign_char, p_re,
     1242                                    n_re_digits, n_re_remainder,
     1243                                    re_has_decimal, &locale, &tmp_format);
     1244
     1245    /* Same formatting, but always include a sign, unless the real part is
     1246     * going to be omitted, in which case we use whatever sign convention was
     1247     * requested by the original format. */
     1248    if (!skip_re)
     1249        tmp_format.sign = '+';
     1250    n_im_total = calc_number_widths(&im_spec, 0, im_sign_char, p_im,
     1251                                    n_im_digits, n_im_remainder,
     1252                                    im_has_decimal, &locale, &tmp_format);
     1253
     1254    if (skip_re)
     1255        n_re_total = 0;
     1256
     1257    /* Add 1 for the 'j', and optionally 2 for parens. */
     1258    calc_padding(n_re_total + n_im_total + 1 + add_parens * 2,
     1259                 format->width, format->align, &lpad, &rpad, &total);
     1260
     1261    result = STRINGLIB_NEW(NULL, total);
     1262    if (result == NULL)
     1263        goto done;
     1264
     1265    /* Populate the memory. First, the padding. */
     1266    p = fill_padding(STRINGLIB_STR(result),
     1267                     n_re_total + n_im_total + 1 + add_parens * 2,
     1268                     format->fill_char=='\0' ? ' ' : format->fill_char,
     1269                     lpad, rpad);
     1270
     1271    if (add_parens)
     1272        *p++ = '(';
     1273
     1274    if (!skip_re) {
     1275        fill_number(p, &re_spec, p_re, n_re_digits, NULL, 0, &locale, 0);
     1276        p += n_re_total;
     1277    }
     1278    fill_number(p, &im_spec, p_im, n_im_digits, NULL, 0, &locale, 0);
     1279    p += n_im_total;
     1280    *p++ = 'j';
     1281
     1282    if (add_parens)
     1283        *p++ = ')';
     1284
     1285done:
     1286    PyMem_Free(re_buf);
     1287    PyMem_Free(im_buf);
     1288#if STRINGLIB_IS_UNICODE
     1289    PyMem_Free(re_unicode_tmp);
     1290    PyMem_Free(im_unicode_tmp);
     1291#endif
     1292    return result;
     1293}
     1294#endif /* FORMAT_COMPLEX */
    8531295
    8541296/************************************************************************/
     
    8571299PyObject *
    8581300FORMAT_STRING(PyObject *obj,
    859               STRINGLIB_CHAR *format_spec,
    860               Py_ssize_t format_spec_len)
     1301              STRINGLIB_CHAR *format_spec,
     1302              Py_ssize_t format_spec_len)
    8611303{
    8621304    InternalFormatSpec format;
     
    8721314    /* parse the format_spec */
    8731315    if (!parse_internal_render_format_spec(format_spec, format_spec_len,
    874                                            &format, 's'))
     1316                                           &format, 's', '<'))
    8751317        goto done;
    8761318
     
    8941336static PyObject*
    8951337format_int_or_long(PyObject* obj,
    896                    STRINGLIB_CHAR *format_spec,
    897                    Py_ssize_t format_spec_len,
    898                    IntOrLongToString tostring)
     1338                   STRINGLIB_CHAR *format_spec,
     1339                   Py_ssize_t format_spec_len,
     1340                   IntOrLongToString tostring)
    8991341{
    9001342    PyObject *result = NULL;
     
    9111353    /* parse the format_spec */
    9121354    if (!parse_internal_render_format_spec(format_spec,
    913                                            format_spec_len,
    914                                            &format, 'd'))
     1355                                           format_spec_len,
     1356                                           &format, 'd', '>'))
    9151357        goto done;
    9161358
     
    9251367    case 'n':
    9261368        /* no type conversion needed, already an int (or long).  do
    927            the formatting */
    928             result = format_int_or_long_internal(obj, &format, tostring);
     1369           the formatting */
     1370            result = format_int_or_long_internal(obj, &format, tostring);
    9291371        break;
    9301372
     
    9751417PyObject *
    9761418FORMAT_LONG(PyObject *obj,
    977             STRINGLIB_CHAR *format_spec,
    978             Py_ssize_t format_spec_len)
     1419            STRINGLIB_CHAR *format_spec,
     1420            Py_ssize_t format_spec_len)
    9791421{
    9801422    return format_int_or_long(obj, format_spec, format_spec_len,
    981                               long_format);
     1423                              long_format);
    9821424}
    9831425#endif /* FORMAT_LONG */
     
    9961438PyObject *
    9971439FORMAT_INT(PyObject *obj,
    998            STRINGLIB_CHAR *format_spec,
    999            Py_ssize_t format_spec_len)
     1440           STRINGLIB_CHAR *format_spec,
     1441           Py_ssize_t format_spec_len)
    10001442{
    10011443    return format_int_or_long(obj, format_spec, format_spec_len,
    1002                               int_format);
     1444                              int_format);
    10031445}
    10041446#endif /* FORMAT_INT */
     
    10071449PyObject *
    10081450FORMAT_FLOAT(PyObject *obj,
    1009              STRINGLIB_CHAR *format_spec,
    1010              Py_ssize_t format_spec_len)
     1451             STRINGLIB_CHAR *format_spec,
     1452             Py_ssize_t format_spec_len)
    10111453{
    10121454    PyObject *result = NULL;
     
    10221464    /* parse the format_spec */
    10231465    if (!parse_internal_render_format_spec(format_spec,
    1024                                            format_spec_len,
    1025                                            &format, '\0'))
     1466                                           format_spec_len,
     1467                                           &format, '\0', '>'))
    10261468        goto done;
    10271469
    10281470    /* type conversion? */
    10291471    switch (format.type) {
    1030     case '\0':
    1031         /* 'Z' means like 'g', but with at least one decimal.  See
    1032            PyOS_ascii_formatd */
    1033         format.type = 'Z';
    1034         /* Deliberate fall through to the next case statement */
     1472    case '\0': /* No format code: like 'g', but with at least one decimal. */
    10351473    case 'e':
    10361474    case 'E':
     
    10551493}
    10561494#endif /* FORMAT_FLOAT */
     1495
     1496#ifdef FORMAT_COMPLEX
     1497PyObject *
     1498FORMAT_COMPLEX(PyObject *obj,
     1499               STRINGLIB_CHAR *format_spec,
     1500               Py_ssize_t format_spec_len)
     1501{
     1502    PyObject *result = NULL;
     1503    InternalFormatSpec format;
     1504
     1505    /* check for the special case of zero length format spec, make
     1506       it equivalent to str(obj) */
     1507    if (format_spec_len == 0) {
     1508        result = STRINGLIB_TOSTR(obj);
     1509        goto done;
     1510    }
     1511
     1512    /* parse the format_spec */
     1513    if (!parse_internal_render_format_spec(format_spec,
     1514                                           format_spec_len,
     1515                                           &format, '\0', '>'))
     1516        goto done;
     1517
     1518    /* type conversion? */
     1519    switch (format.type) {
     1520    case '\0': /* No format code: like 'g', but with at least one decimal. */
     1521    case 'e':
     1522    case 'E':
     1523    case 'f':
     1524    case 'F':
     1525    case 'g':
     1526    case 'G':
     1527    case 'n':
     1528        /* no conversion, already a complex.  do the formatting */
     1529        result = format_complex_internal(obj, &format);
     1530        break;
     1531
     1532    default:
     1533        /* unknown */
     1534        unknown_presentation_type(format.type, obj->ob_type->tp_name);
     1535        goto done;
     1536    }
     1537
     1538done:
     1539    return result;
     1540}
     1541#endif /* FORMAT_COMPLEX */
Note: See TracChangeset for help on using the changeset viewer.