1 /* stringlib: locale related helpers implementation */ 2 3 #ifndef STRINGLIB_LOCALEUTIL_H 4 #define STRINGLIB_LOCALEUTIL_H 5 6 #include <locale.h> 7 8 #define MAX(x, y) ((x) < (y) ? (y) : (x)) 9 #define MIN(x, y) ((x) < (y) ? (x) : (y)) 10 11 typedef struct { 12 const char *grouping; 13 char previous; 14 Py_ssize_t i; /* Where we're currently pointing in grouping. */ 15 } GroupGenerator; 16 17 static void 18 _GroupGenerator_init(GroupGenerator *self, const char *grouping) 19 { 20 self->grouping = grouping; 21 self->i = 0; 22 self->previous = 0; 23 } 24 25 /* Returns the next grouping, or 0 to signify end. */ 26 static Py_ssize_t 27 _GroupGenerator_next(GroupGenerator *self) 28 { 29 /* Note that we don't really do much error checking here. If a 30 grouping string contains just CHAR_MAX, for example, then just 31 terminate the generator. That shouldn't happen, but at least we 32 fail gracefully. */ 33 switch (self->grouping[self->i]) { 34 case 0: 35 return self->previous; 36 case CHAR_MAX: 37 /* Stop the generator. */ 38 return 0; 39 default: { 40 char ch = self->grouping[self->i]; 41 self->previous = ch; 42 self->i++; 43 return (Py_ssize_t)ch; 44 } 45 } 46 } 47 48 /* Fill in some digits, leading zeros, and thousands separator. All 49 are optional, depending on when we're called. */ 50 static void 51 fill(STRINGLIB_CHAR **digits_end, STRINGLIB_CHAR **buffer_end, 52 Py_ssize_t n_chars, Py_ssize_t n_zeros, const char* thousands_sep, 53 Py_ssize_t thousands_sep_len) 54 { 55 #if STRINGLIB_IS_UNICODE 56 Py_ssize_t i; 57 #endif 58 59 if (thousands_sep) { 60 *buffer_end -= thousands_sep_len; 61 62 /* Copy the thousands_sep chars into the buffer. */ 63 #if STRINGLIB_IS_UNICODE 64 /* Convert from the char's of the thousands_sep from 65 the locale into unicode. */ 66 for (i = 0; i < thousands_sep_len; ++i) 67 (*buffer_end)[i] = thousands_sep[i]; 68 #else 69 /* No conversion, just memcpy the thousands_sep. */ 70 memcpy(*buffer_end, thousands_sep, thousands_sep_len); 71 #endif 72 } 73 74 *buffer_end -= n_chars; 75 *digits_end -= n_chars; 76 memcpy(*buffer_end, *digits_end, n_chars * sizeof(STRINGLIB_CHAR)); 77 78 *buffer_end -= n_zeros; 79 STRINGLIB_FILL(*buffer_end, '0', n_zeros); 80 } 81 82 /** 83 * _Py_InsertThousandsGrouping: 84 * @buffer: A pointer to the start of a string. 85 * @n_buffer: Number of characters in @buffer. 86 * @digits: A pointer to the digits we're reading from. If count 87 * is non-NULL, this is unused. 88 * @n_digits: The number of digits in the string, in which we want 89 * to put the grouping chars. 90 * @min_width: The minimum width of the digits in the output string. 91 * Output will be zero-padded on the left to fill. 92 * @grouping: see definition in localeconv(). 93 * @thousands_sep: see definition in localeconv(). 94 * 95 * There are 2 modes: counting and filling. If @buffer is NULL, 96 * we are in counting mode, else filling mode. 97 * If counting, the required buffer size is returned. 98 * If filling, we know the buffer will be large enough, so we don't 99 * need to pass in the buffer size. 100 * Inserts thousand grouping characters (as defined by grouping and 101 * thousands_sep) into the string between buffer and buffer+n_digits. 102 * 103 * Return value: 0 on error, else 1. Note that no error can occur if 104 * count is non-NULL. 105 * 106 * This name won't be used, the includer of this file should define 107 * it to be the actual function name, based on unicode or string. 108 * 109 * As closely as possible, this code mimics the logic in decimal.py's 110 _insert_thousands_sep(). 111 **/ 112 Py_ssize_t 113 _Py_InsertThousandsGrouping(STRINGLIB_CHAR *buffer, 114 Py_ssize_t n_buffer, 115 STRINGLIB_CHAR *digits, 116 Py_ssize_t n_digits, 117 Py_ssize_t min_width, 118 const char *grouping, 119 const char *thousands_sep) 120 { 121 Py_ssize_t count = 0; 122 Py_ssize_t n_zeros; 123 int loop_broken = 0; 124 int use_separator = 0; /* First time through, don't append the 125 separator. They only go between 126 groups. */ 127 STRINGLIB_CHAR *buffer_end = NULL; 128 STRINGLIB_CHAR *digits_end = NULL; 129 Py_ssize_t l; 130 Py_ssize_t n_chars; 131 Py_ssize_t thousands_sep_len = strlen(thousands_sep); 132 Py_ssize_t remaining = n_digits; /* Number of chars remaining to 133 be looked at */ 134 /* A generator that returns all of the grouping widths, until it 135 returns 0. */ 136 GroupGenerator groupgen; 137 _GroupGenerator_init(&groupgen, grouping); 138 139 if (buffer) { 140 buffer_end = buffer + n_buffer; 141 digits_end = digits + n_digits; 142 } 143 144 while ((l = _GroupGenerator_next(&groupgen)) > 0) { 145 l = MIN(l, MAX(MAX(remaining, min_width), 1)); 146 n_zeros = MAX(0, l - remaining); 147 n_chars = MAX(0, MIN(remaining, l)); 148 149 /* Use n_zero zero's and n_chars chars */ 150 151 /* Count only, don't do anything. */ 152 count += (use_separator ? thousands_sep_len : 0) + n_zeros + n_chars; 153 154 if (buffer) { 155 /* Copy into the output buffer. */ 156 fill(&digits_end, &buffer_end, n_chars, n_zeros, 157 use_separator ? thousands_sep : NULL, thousands_sep_len); 158 } 159 160 /* Use a separator next time. */ 161 use_separator = 1; 162 163 remaining -= n_chars; 164 min_width -= l; 165 166 if (remaining <= 0 && min_width <= 0) { 167 loop_broken = 1; 168 break; 169 } 170 min_width -= thousands_sep_len; 171 } 172 if (!loop_broken) { 173 /* We left the loop without using a break statement. */ 174 175 l = MAX(MAX(remaining, min_width), 1); 176 n_zeros = MAX(0, l - remaining); 177 n_chars = MAX(0, MIN(remaining, l)); 178 179 /* Use n_zero zero's and n_chars chars */ 180 count += (use_separator ? thousands_sep_len : 0) + n_zeros + n_chars; 181 if (buffer) { 182 /* Copy into the output buffer. */ 183 fill(&digits_end, &buffer_end, n_chars, n_zeros, 184 use_separator ? thousands_sep : NULL, thousands_sep_len); 185 } 186 } 187 return count; 188 } 189 190 /** 191 * _Py_InsertThousandsGroupingLocale: 192 * @buffer: A pointer to the start of a string. 193 * @n_digits: The number of digits in the string, in which we want 194 * to put the grouping chars. 195 * 196 * Reads thee current locale and calls _Py_InsertThousandsGrouping(). 197 **/ 198 Py_ssize_t 199 _Py_InsertThousandsGroupingLocale(STRINGLIB_CHAR *buffer, 200 Py_ssize_t n_buffer, 201 STRINGLIB_CHAR *digits, 202 Py_ssize_t n_digits, 203 Py_ssize_t min_width) 204 { 205 struct lconv *locale_data = localeconv(); 206 const char *grouping = locale_data->grouping; 207 const char *thousands_sep = locale_data->thousands_sep; 208 209 return _Py_InsertThousandsGrouping(buffer, n_buffer, digits, n_digits, 210 min_width, grouping, thousands_sep); 211 } 212 #endif /* STRINGLIB_LOCALEUTIL_H */ 213