Back to index

python3.2  3.2.2
Classes | Defines | Functions
localeutil.h File Reference
#include <locale.h>
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  GroupGenerator

Defines

#define MAX(x, y)   ((x) < (y) ? (y) : (x))
#define MIN(x, y)   ((x) < (y) ? (x) : (y))

Functions

static void _GroupGenerator_init (GroupGenerator *self, const char *grouping)
static Py_ssize_t _GroupGenerator_next (GroupGenerator *self)
static void fill (STRINGLIB_CHAR **digits_end, STRINGLIB_CHAR **buffer_end, Py_ssize_t n_chars, Py_ssize_t n_zeros, const char *thousands_sep, Py_ssize_t thousands_sep_len)
Py_ssize_t _Py_InsertThousandsGrouping (STRINGLIB_CHAR *buffer, Py_ssize_t n_buffer, STRINGLIB_CHAR *digits, Py_ssize_t n_digits, Py_ssize_t min_width, const char *grouping, const char *thousands_sep)
 _Py_InsertThousandsGrouping: : A pointer to the start of a string.
Py_ssize_t _Py_InsertThousandsGroupingLocale (STRINGLIB_CHAR *buffer, Py_ssize_t n_buffer, STRINGLIB_CHAR *digits, Py_ssize_t n_digits, Py_ssize_t min_width)
 _Py_InsertThousandsGroupingLocale: : A pointer to the start of a string.

Class Documentation

struct GroupGenerator

Definition at line 11 of file localeutil.h.

Class Members
const char * grouping
Py_ssize_t i
char previous

Define Documentation

#define MAX (   x,
 
)    ((x) < (y) ? (y) : (x))

Definition at line 8 of file localeutil.h.

#define MIN (   x,
 
)    ((x) < (y) ? (x) : (y))

Definition at line 9 of file localeutil.h.


Function Documentation

static void _GroupGenerator_init ( GroupGenerator self,
const char *  grouping 
) [static]

Definition at line 18 of file localeutil.h.

{
    self->grouping = grouping;
    self->i = 0;
    self->previous = 0;
}

Here is the caller graph for this function:

static Py_ssize_t _GroupGenerator_next ( GroupGenerator self) [static]

Definition at line 27 of file localeutil.h.

{
    /* Note that we don't really do much error checking here. If a
       grouping string contains just CHAR_MAX, for example, then just
       terminate the generator. That shouldn't happen, but at least we
       fail gracefully. */
    switch (self->grouping[self->i]) {
    case 0:
        return self->previous;
    case CHAR_MAX:
        /* Stop the generator. */
        return 0;
    default: {
        char ch = self->grouping[self->i];
        self->previous = ch;
        self->i++;
        return (Py_ssize_t)ch;
    }
    }
}

Here is the caller graph for this function:

Py_ssize_t _Py_InsertThousandsGrouping ( STRINGLIB_CHAR buffer,
Py_ssize_t  n_buffer,
STRINGLIB_CHAR digits,
Py_ssize_t  n_digits,
Py_ssize_t  min_width,
const char *  grouping,
const char *  thousands_sep 
)

_Py_InsertThousandsGrouping: : A pointer to the start of a string.

: Number of characters in . : A pointer to the digits we're reading from. If count is non-NULL, this is unused. : The number of digits in the string, in which we want to put the grouping chars. : The minimum width of the digits in the output string. Output will be zero-padded on the left to fill. : see definition in localeconv(). : see definition in localeconv().

There are 2 modes: counting and filling. If is NULL, we are in counting mode, else filling mode. If counting, the required buffer size is returned. If filling, we know the buffer will be large enough, so we don't need to pass in the buffer size. Inserts thousand grouping characters (as defined by grouping and thousands_sep) into the string between buffer and buffer+n_digits.

Return value: 0 on error, else 1. Note that no error can occur if count is non-NULL.

This name won't be used, the includer of this file should define it to be the actual function name, based on unicode or string.

As closely as possible, this code mimics the logic in decimal.py's _insert_thousands_sep().

Definition at line 113 of file localeutil.h.

{
    Py_ssize_t count = 0;
    Py_ssize_t n_zeros;
    int loop_broken = 0;
    int use_separator = 0; /* First time through, don't append the
                              separator. They only go between
                              groups. */
    STRINGLIB_CHAR *buffer_end = NULL;
    STRINGLIB_CHAR *digits_end = NULL;
    Py_ssize_t l;
    Py_ssize_t n_chars;
    Py_ssize_t thousands_sep_len = strlen(thousands_sep);
    Py_ssize_t remaining = n_digits; /* Number of chars remaining to
                                        be looked at */
    /* A generator that returns all of the grouping widths, until it
       returns 0. */
    GroupGenerator groupgen;
    _GroupGenerator_init(&groupgen, grouping);

    if (buffer) {
        buffer_end = buffer + n_buffer;
        digits_end = digits + n_digits;
    }

    while ((l = _GroupGenerator_next(&groupgen)) > 0) {
        l = MIN(l, MAX(MAX(remaining, min_width), 1));
        n_zeros = MAX(0, l - remaining);
        n_chars = MAX(0, MIN(remaining, l));

        /* Use n_zero zero's and n_chars chars */

        /* Count only, don't do anything. */
        count += (use_separator ? thousands_sep_len : 0) + n_zeros + n_chars;

        if (buffer) {
            /* Copy into the output buffer. */
            fill(&digits_end, &buffer_end, n_chars, n_zeros,
                 use_separator ? thousands_sep : NULL, thousands_sep_len);
        }

        /* Use a separator next time. */
        use_separator = 1;

        remaining -= n_chars;
        min_width -= l;

        if (remaining <= 0 && min_width <= 0) {
            loop_broken = 1;
            break;
        }
        min_width -= thousands_sep_len;
    }
    if (!loop_broken) {
        /* We left the loop without using a break statement. */

        l = MAX(MAX(remaining, min_width), 1);
        n_zeros = MAX(0, l - remaining);
        n_chars = MAX(0, MIN(remaining, l));

        /* Use n_zero zero's and n_chars chars */
        count += (use_separator ? thousands_sep_len : 0) + n_zeros + n_chars;
        if (buffer) {
            /* Copy into the output buffer. */
            fill(&digits_end, &buffer_end, n_chars, n_zeros,
                 use_separator ? thousands_sep : NULL, thousands_sep_len);
        }
    }
    return count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Py_ssize_t _Py_InsertThousandsGroupingLocale ( STRINGLIB_CHAR buffer,
Py_ssize_t  n_buffer,
STRINGLIB_CHAR digits,
Py_ssize_t  n_digits,
Py_ssize_t  min_width 
)

_Py_InsertThousandsGroupingLocale: : A pointer to the start of a string.

: The number of digits in the string, in which we want to put the grouping chars.

Reads thee current locale and calls _Py_InsertThousandsGrouping().

Definition at line 199 of file localeutil.h.

{
        struct lconv *locale_data = localeconv();
        const char *grouping = locale_data->grouping;
        const char *thousands_sep = locale_data->thousands_sep;

        return _Py_InsertThousandsGrouping(buffer, n_buffer, digits, n_digits,
                                           min_width, grouping, thousands_sep);
}

Here is the call graph for this function:

static void fill ( STRINGLIB_CHAR **  digits_end,
STRINGLIB_CHAR **  buffer_end,
Py_ssize_t  n_chars,
Py_ssize_t  n_zeros,
const char *  thousands_sep,
Py_ssize_t  thousands_sep_len 
) [static]

Definition at line 51 of file localeutil.h.

{
#if STRINGLIB_IS_UNICODE
    Py_ssize_t i;
#endif

    if (thousands_sep) {
        *buffer_end -= thousands_sep_len;

        /* Copy the thousands_sep chars into the buffer. */
#if STRINGLIB_IS_UNICODE
        /* Convert from the char's of the thousands_sep from
           the locale into unicode. */
        for (i = 0; i < thousands_sep_len; ++i)
            (*buffer_end)[i] = thousands_sep[i];
#else
        /* No conversion, just memcpy the thousands_sep. */
        memcpy(*buffer_end, thousands_sep, thousands_sep_len);
#endif
    }

    *buffer_end -= n_chars;
    *digits_end -= n_chars;
    memcpy(*buffer_end, *digits_end, n_chars * sizeof(STRINGLIB_CHAR));

    *buffer_end -= n_zeros;
    STRINGLIB_FILL(*buffer_end, '0', n_zeros);
}

Here is the caller graph for this function: