+++ /dev/null
-/** @file\r
- stringlib: locale related helpers implementation.\r
-\r
- Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
- This program and the accompanying materials are licensed and made available under\r
- the terms and conditions of the BSD License that accompanies this distribution.\r
- The full text of the license may be found at\r
- http://opensource.org/licenses/bsd-license.\r
-\r
- THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
- WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-**/\r
-\r
-#ifndef STRINGLIB_LOCALEUTIL_H\r
-#define STRINGLIB_LOCALEUTIL_H\r
-\r
-#include <locale.h>\r
-\r
-// Prevent conflicts with EFI\r
-#undef MAX\r
-#undef MIN\r
-\r
-#define MAX(x, y) ((x) < (y) ? (y) : (x))\r
-#define MIN(x, y) ((x) < (y) ? (x) : (y))\r
-\r
-typedef struct {\r
- const char *grouping;\r
- char previous;\r
- Py_ssize_t i; /* Where we're currently pointing in grouping. */\r
-} GroupGenerator;\r
-\r
-static void\r
-_GroupGenerator_init(GroupGenerator *self, const char *grouping)\r
-{\r
- self->grouping = grouping;\r
- self->i = 0;\r
- self->previous = 0;\r
-}\r
-\r
-/* Returns the next grouping, or 0 to signify end. */\r
-static Py_ssize_t\r
-_GroupGenerator_next(GroupGenerator *self)\r
-{\r
- /* Note that we don't really do much error checking here. If a\r
- grouping string contains just CHAR_MAX, for example, then just\r
- terminate the generator. That shouldn't happen, but at least we\r
- fail gracefully. */\r
- switch (self->grouping[self->i]) {\r
- case 0:\r
- return self->previous;\r
- case CHAR_MAX:\r
- /* Stop the generator. */\r
- return 0;\r
- default: {\r
- char ch = self->grouping[self->i];\r
- self->previous = ch;\r
- self->i++;\r
- return (Py_ssize_t)ch;\r
- }\r
- }\r
-}\r
-\r
-/* Fill in some digits, leading zeros, and thousands separator. All\r
- are optional, depending on when we're called. */\r
-static void\r
-fill(STRINGLIB_CHAR **digits_end, STRINGLIB_CHAR **buffer_end,\r
- Py_ssize_t n_chars, Py_ssize_t n_zeros, const char* thousands_sep,\r
- Py_ssize_t thousands_sep_len)\r
-{\r
-#if STRINGLIB_IS_UNICODE\r
- Py_ssize_t i;\r
-#endif\r
-\r
- if (thousands_sep) {\r
- *buffer_end -= thousands_sep_len;\r
-\r
- /* Copy the thousands_sep chars into the buffer. */\r
-#if STRINGLIB_IS_UNICODE\r
- /* Convert from the char's of the thousands_sep from\r
- the locale into unicode. */\r
- for (i = 0; i < thousands_sep_len; ++i)\r
- (*buffer_end)[i] = thousands_sep[i];\r
-#else\r
- /* No conversion, just memcpy the thousands_sep. */\r
- memcpy(*buffer_end, thousands_sep, thousands_sep_len);\r
-#endif\r
- }\r
-\r
- *buffer_end -= n_chars;\r
- *digits_end -= n_chars;\r
- memcpy(*buffer_end, *digits_end, n_chars * sizeof(STRINGLIB_CHAR));\r
-\r
- *buffer_end -= n_zeros;\r
- STRINGLIB_FILL(*buffer_end, '0', n_zeros);\r
-}\r
-\r
-/**\r
- * _Py_InsertThousandsGrouping:\r
- * @buffer: A pointer to the start of a string.\r
- * @n_buffer: Number of characters in @buffer.\r
- * @digits: A pointer to the digits we're reading from. If count\r
- * is non-NULL, this is unused.\r
- * @n_digits: The number of digits in the string, in which we want\r
- * to put the grouping chars.\r
- * @min_width: The minimum width of the digits in the output string.\r
- * Output will be zero-padded on the left to fill.\r
- * @grouping: see definition in localeconv().\r
- * @thousands_sep: see definition in localeconv().\r
- *\r
- * There are 2 modes: counting and filling. If @buffer is NULL,\r
- * we are in counting mode, else filling mode.\r
- * If counting, the required buffer size is returned.\r
- * If filling, we know the buffer will be large enough, so we don't\r
- * need to pass in the buffer size.\r
- * Inserts thousand grouping characters (as defined by grouping and\r
- * thousands_sep) into the string between buffer and buffer+n_digits.\r
- *\r
- * Return value: 0 on error, else 1. Note that no error can occur if\r
- * count is non-NULL.\r
- *\r
- * This name won't be used, the includer of this file should define\r
- * it to be the actual function name, based on unicode or string.\r
- *\r
- * As closely as possible, this code mimics the logic in decimal.py's\r
- _insert_thousands_sep().\r
- **/\r
-Py_ssize_t\r
-_Py_InsertThousandsGrouping(STRINGLIB_CHAR *buffer,\r
- Py_ssize_t n_buffer,\r
- STRINGLIB_CHAR *digits,\r
- Py_ssize_t n_digits,\r
- Py_ssize_t min_width,\r
- const char *grouping,\r
- const char *thousands_sep)\r
-{\r
- Py_ssize_t count = 0;\r
- Py_ssize_t n_zeros;\r
- int loop_broken = 0;\r
- int use_separator = 0; /* First time through, don't append the\r
- separator. They only go between\r
- groups. */\r
- STRINGLIB_CHAR *buffer_end = NULL;\r
- STRINGLIB_CHAR *digits_end = NULL;\r
- Py_ssize_t l;\r
- Py_ssize_t n_chars;\r
- Py_ssize_t thousands_sep_len = strlen(thousands_sep);\r
- Py_ssize_t remaining = n_digits; /* Number of chars remaining to\r
- be looked at */\r
- /* A generator that returns all of the grouping widths, until it\r
- returns 0. */\r
- GroupGenerator groupgen;\r
- _GroupGenerator_init(&groupgen, grouping);\r
-\r
- if (buffer) {\r
- buffer_end = buffer + n_buffer;\r
- digits_end = digits + n_digits;\r
- }\r
-\r
- while ((l = _GroupGenerator_next(&groupgen)) > 0) {\r
- l = MIN(l, MAX(MAX(remaining, min_width), 1));\r
- n_zeros = MAX(0, l - remaining);\r
- n_chars = MAX(0, MIN(remaining, l));\r
-\r
- /* Use n_zero zero's and n_chars chars */\r
-\r
- /* Count only, don't do anything. */\r
- count += (use_separator ? thousands_sep_len : 0) + n_zeros + n_chars;\r
-\r
- if (buffer) {\r
- /* Copy into the output buffer. */\r
- fill(&digits_end, &buffer_end, n_chars, n_zeros,\r
- use_separator ? thousands_sep : NULL, thousands_sep_len);\r
- }\r
-\r
- /* Use a separator next time. */\r
- use_separator = 1;\r
-\r
- remaining -= n_chars;\r
- min_width -= l;\r
-\r
- if (remaining <= 0 && min_width <= 0) {\r
- loop_broken = 1;\r
- break;\r
- }\r
- min_width -= thousands_sep_len;\r
- }\r
- if (!loop_broken) {\r
- /* We left the loop without using a break statement. */\r
-\r
- l = MAX(MAX(remaining, min_width), 1);\r
- n_zeros = MAX(0, l - remaining);\r
- n_chars = MAX(0, MIN(remaining, l));\r
-\r
- /* Use n_zero zero's and n_chars chars */\r
- count += (use_separator ? thousands_sep_len : 0) + n_zeros + n_chars;\r
- if (buffer) {\r
- /* Copy into the output buffer. */\r
- fill(&digits_end, &buffer_end, n_chars, n_zeros,\r
- use_separator ? thousands_sep : NULL, thousands_sep_len);\r
- }\r
- }\r
- return count;\r
-}\r
-\r
-/**\r
- * _Py_InsertThousandsGroupingLocale:\r
- * @buffer: A pointer to the start of a string.\r
- * @n_digits: The number of digits in the string, in which we want\r
- * to put the grouping chars.\r
- *\r
- * Reads thee current locale and calls _Py_InsertThousandsGrouping().\r
- **/\r
-Py_ssize_t\r
-_Py_InsertThousandsGroupingLocale(STRINGLIB_CHAR *buffer,\r
- Py_ssize_t n_buffer,\r
- STRINGLIB_CHAR *digits,\r
- Py_ssize_t n_digits,\r
- Py_ssize_t min_width)\r
-{\r
- struct lconv *locale_data = localeconv();\r
- const char *grouping = locale_data->grouping;\r
- const char *thousands_sep = locale_data->thousands_sep;\r
-\r
- return _Py_InsertThousandsGrouping(buffer, n_buffer, digits, n_digits,\r
- min_width, grouping, thousands_sep);\r
-}\r
-#endif /* STRINGLIB_LOCALEUTIL_H */\r
projects / mirror_edk2.git / blobdiff