Restoring authorship annotation for <orivej@yandex-team.ru>. Commit 1 of 2.

1 files changed, 1558 insertions, 1558 deletions

diff --git a/contrib/tools/python3/src/Python/formatter_unicode.c b/contrib/tools/python3/src/Python/formatter_unicode.c
index e7ec4dd5cb..b76f2e5473 100644
--- a/contrib/tools/python3/src/Python/formatter_unicode.c
+++ b/contrib/tools/python3/src/Python/formatter_unicode.c
@@ -1,778 +1,778 @@
-/* implements the unicode (as opposed to string) version of the
-   built-in formatters for string, int, float.  that is, the versions
-   of int.__float__, etc., that take and return unicode objects */
-
-#include "Python.h"
+/* implements the unicode (as opposed to string) version of the 
+   built-in formatters for string, int, float.  that is, the versions 
+   of int.__float__, etc., that take and return unicode objects */ 
+ 
+#include "Python.h" 
 #include "pycore_fileutils.h"
-#include <locale.h>
-
-/* Raises an exception about an unknown presentation type for this
- * type. */
-
-static void
-unknown_presentation_type(Py_UCS4 presentation_type,
-                          const char* type_name)
-{
-    /* %c might be out-of-range, hence the two cases. */
-    if (presentation_type > 32 && presentation_type < 128)
-        PyErr_Format(PyExc_ValueError,
-                     "Unknown format code '%c' "
-                     "for object of type '%.200s'",
-                     (char)presentation_type,
-                     type_name);
-    else
-        PyErr_Format(PyExc_ValueError,
-                     "Unknown format code '\\x%x' "
-                     "for object of type '%.200s'",
-                     (unsigned int)presentation_type,
-                     type_name);
-}
-
-static void
-invalid_thousands_separator_type(char specifier, Py_UCS4 presentation_type)
-{
-    assert(specifier == ',' || specifier == '_');
-    if (presentation_type > 32 && presentation_type < 128)
-        PyErr_Format(PyExc_ValueError,
-                     "Cannot specify '%c' with '%c'.",
-                     specifier, (char)presentation_type);
-    else
-        PyErr_Format(PyExc_ValueError,
-                     "Cannot specify '%c' with '\\x%x'.",
-                     specifier, (unsigned int)presentation_type);
-}
-
-static void
-invalid_comma_and_underscore(void)
-{
-    PyErr_Format(PyExc_ValueError, "Cannot specify both ',' and '_'.");
-}
-
-/*
-    get_integer consumes 0 or more decimal digit characters from an
-    input string, updates *result with the corresponding positive
-    integer, and returns the number of digits consumed.
-
-    returns -1 on error.
-*/
-static int
-get_integer(PyObject *str, Py_ssize_t *ppos, Py_ssize_t end,
-                  Py_ssize_t *result)
-{
-    Py_ssize_t accumulator, digitval, pos = *ppos;
-    int numdigits;
-    int kind = PyUnicode_KIND(str);
+#include <locale.h> 
+ 
+/* Raises an exception about an unknown presentation type for this 
+ * type. */ 
+ 
+static void 
+unknown_presentation_type(Py_UCS4 presentation_type, 
+                          const char* type_name) 
+{ 
+    /* %c might be out-of-range, hence the two cases. */ 
+    if (presentation_type > 32 && presentation_type < 128) 
+        PyErr_Format(PyExc_ValueError, 
+                     "Unknown format code '%c' " 
+                     "for object of type '%.200s'", 
+                     (char)presentation_type, 
+                     type_name); 
+    else 
+        PyErr_Format(PyExc_ValueError, 
+                     "Unknown format code '\\x%x' " 
+                     "for object of type '%.200s'", 
+                     (unsigned int)presentation_type, 
+                     type_name); 
+} 
+ 
+static void 
+invalid_thousands_separator_type(char specifier, Py_UCS4 presentation_type) 
+{ 
+    assert(specifier == ',' || specifier == '_'); 
+    if (presentation_type > 32 && presentation_type < 128) 
+        PyErr_Format(PyExc_ValueError, 
+                     "Cannot specify '%c' with '%c'.", 
+                     specifier, (char)presentation_type); 
+    else 
+        PyErr_Format(PyExc_ValueError, 
+                     "Cannot specify '%c' with '\\x%x'.", 
+                     specifier, (unsigned int)presentation_type); 
+} 
+ 
+static void 
+invalid_comma_and_underscore(void) 
+{ 
+    PyErr_Format(PyExc_ValueError, "Cannot specify both ',' and '_'."); 
+} 
+ 
+/* 
+    get_integer consumes 0 or more decimal digit characters from an 
+    input string, updates *result with the corresponding positive 
+    integer, and returns the number of digits consumed. 
+ 
+    returns -1 on error. 
+*/ 
+static int 
+get_integer(PyObject *str, Py_ssize_t *ppos, Py_ssize_t end, 
+                  Py_ssize_t *result) 
+{ 
+    Py_ssize_t accumulator, digitval, pos = *ppos; 
+    int numdigits; 
+    int kind = PyUnicode_KIND(str); 
     const void *data = PyUnicode_DATA(str);
-
-    accumulator = numdigits = 0;
-    for (; pos < end; pos++, numdigits++) {
-        digitval = Py_UNICODE_TODECIMAL(PyUnicode_READ(kind, data, pos));
-        if (digitval < 0)
-            break;
-        /*
-           Detect possible overflow before it happens:
-
-              accumulator * 10 + digitval > PY_SSIZE_T_MAX if and only if
-              accumulator > (PY_SSIZE_T_MAX - digitval) / 10.
-        */
-        if (accumulator > (PY_SSIZE_T_MAX - digitval) / 10) {
-            PyErr_Format(PyExc_ValueError,
-                         "Too many decimal digits in format string");
-            *ppos = pos;
-            return -1;
-        }
-        accumulator = accumulator * 10 + digitval;
-    }
-    *ppos = pos;
-    *result = accumulator;
-    return numdigits;
-}
-
-/************************************************************************/
-/*********** standard format specifier parsing **************************/
-/************************************************************************/
-
-/* returns true if this character is a specifier alignment token */
-Py_LOCAL_INLINE(int)
-is_alignment_token(Py_UCS4 c)
-{
-    switch (c) {
-    case '<': case '>': case '=': case '^':
-        return 1;
-    default:
-        return 0;
-    }
-}
-
-/* returns true if this character is a sign element */
-Py_LOCAL_INLINE(int)
-is_sign_element(Py_UCS4 c)
-{
-    switch (c) {
-    case ' ': case '+': case '-':
-        return 1;
-    default:
-        return 0;
-    }
-}
-
-/* Locale type codes. LT_NO_LOCALE must be zero. */
-enum LocaleType {
-    LT_NO_LOCALE = 0,
-    LT_DEFAULT_LOCALE = ',',
-    LT_UNDERSCORE_LOCALE = '_',
-    LT_UNDER_FOUR_LOCALE,
-    LT_CURRENT_LOCALE
-};
-
-typedef struct {
-    Py_UCS4 fill_char;
-    Py_UCS4 align;
-    int alternate;
-    Py_UCS4 sign;
-    Py_ssize_t width;
-    enum LocaleType thousands_separators;
-    Py_ssize_t precision;
-    Py_UCS4 type;
-} InternalFormatSpec;
-
-#if 0
-/* Occasionally useful for debugging. Should normally be commented out. */
-static void
-DEBUG_PRINT_FORMAT_SPEC(InternalFormatSpec *format)
-{
-    printf("internal format spec: fill_char %d\n", format->fill_char);
-    printf("internal format spec: align %d\n", format->align);
-    printf("internal format spec: alternate %d\n", format->alternate);
-    printf("internal format spec: sign %d\n", format->sign);
-    printf("internal format spec: width %zd\n", format->width);
-    printf("internal format spec: thousands_separators %d\n",
-           format->thousands_separators);
-    printf("internal format spec: precision %zd\n", format->precision);
-    printf("internal format spec: type %c\n", format->type);
-    printf("\n");
-}
-#endif
-
-
-/*
-  ptr points to the start of the format_spec, end points just past its end.
-  fills in format with the parsed information.
-  returns 1 on success, 0 on failure.
-  if failure, sets the exception
-*/
-static int
-parse_internal_render_format_spec(PyObject *format_spec,
-                                  Py_ssize_t start, Py_ssize_t end,
-                                  InternalFormatSpec *format,
-                                  char default_type,
-                                  char default_align)
-{
-    Py_ssize_t pos = start;
-    int kind = PyUnicode_KIND(format_spec);
+ 
+    accumulator = numdigits = 0; 
+    for (; pos < end; pos++, numdigits++) { 
+        digitval = Py_UNICODE_TODECIMAL(PyUnicode_READ(kind, data, pos)); 
+        if (digitval < 0) 
+            break; 
+        /* 
+           Detect possible overflow before it happens: 
+ 
+              accumulator * 10 + digitval > PY_SSIZE_T_MAX if and only if 
+              accumulator > (PY_SSIZE_T_MAX - digitval) / 10. 
+        */ 
+        if (accumulator > (PY_SSIZE_T_MAX - digitval) / 10) { 
+            PyErr_Format(PyExc_ValueError, 
+                         "Too many decimal digits in format string"); 
+            *ppos = pos; 
+            return -1; 
+        } 
+        accumulator = accumulator * 10 + digitval; 
+    } 
+    *ppos = pos; 
+    *result = accumulator; 
+    return numdigits; 
+} 
+ 
+/************************************************************************/ 
+/*********** standard format specifier parsing **************************/ 
+/************************************************************************/ 
+ 
+/* returns true if this character is a specifier alignment token */ 
+Py_LOCAL_INLINE(int) 
+is_alignment_token(Py_UCS4 c) 
+{ 
+    switch (c) { 
+    case '<': case '>': case '=': case '^': 
+        return 1; 
+    default: 
+        return 0; 
+    } 
+} 
+ 
+/* returns true if this character is a sign element */ 
+Py_LOCAL_INLINE(int) 
+is_sign_element(Py_UCS4 c) 
+{ 
+    switch (c) { 
+    case ' ': case '+': case '-': 
+        return 1; 
+    default: 
+        return 0; 
+    } 
+} 
+ 
+/* Locale type codes. LT_NO_LOCALE must be zero. */ 
+enum LocaleType { 
+    LT_NO_LOCALE = 0, 
+    LT_DEFAULT_LOCALE = ',', 
+    LT_UNDERSCORE_LOCALE = '_', 
+    LT_UNDER_FOUR_LOCALE, 
+    LT_CURRENT_LOCALE 
+}; 
+ 
+typedef struct { 
+    Py_UCS4 fill_char; 
+    Py_UCS4 align; 
+    int alternate; 
+    Py_UCS4 sign; 
+    Py_ssize_t width; 
+    enum LocaleType thousands_separators; 
+    Py_ssize_t precision; 
+    Py_UCS4 type; 
+} InternalFormatSpec; 
+ 
+#if 0 
+/* Occasionally useful for debugging. Should normally be commented out. */ 
+static void 
+DEBUG_PRINT_FORMAT_SPEC(InternalFormatSpec *format) 
+{ 
+    printf("internal format spec: fill_char %d\n", format->fill_char); 
+    printf("internal format spec: align %d\n", format->align); 
+    printf("internal format spec: alternate %d\n", format->alternate); 
+    printf("internal format spec: sign %d\n", format->sign); 
+    printf("internal format spec: width %zd\n", format->width); 
+    printf("internal format spec: thousands_separators %d\n", 
+           format->thousands_separators); 
+    printf("internal format spec: precision %zd\n", format->precision); 
+    printf("internal format spec: type %c\n", format->type); 
+    printf("\n"); 
+} 
+#endif 
+ 
+ 
+/* 
+  ptr points to the start of the format_spec, end points just past its end. 
+  fills in format with the parsed information. 
+  returns 1 on success, 0 on failure. 
+  if failure, sets the exception 
+*/ 
+static int 
+parse_internal_render_format_spec(PyObject *format_spec, 
+                                  Py_ssize_t start, Py_ssize_t end, 
+                                  InternalFormatSpec *format, 
+                                  char default_type, 
+                                  char default_align) 
+{ 
+    Py_ssize_t pos = start; 
+    int kind = PyUnicode_KIND(format_spec); 
     const void *data = PyUnicode_DATA(format_spec);
-    /* end-pos is used throughout this code to specify the length of
-       the input string */
-#define READ_spec(index) PyUnicode_READ(kind, data, index)
-
-    Py_ssize_t consumed;
-    int align_specified = 0;
-    int fill_char_specified = 0;
-
-    format->fill_char = ' ';
-    format->align = default_align;
-    format->alternate = 0;
-    format->sign = '\0';
-    format->width = -1;
-    format->thousands_separators = LT_NO_LOCALE;
-    format->precision = -1;
-    format->type = default_type;
-
-    /* If the second char is an alignment token,
-       then parse the fill char */
-    if (end-pos >= 2 && is_alignment_token(READ_spec(pos+1))) {
-        format->align = READ_spec(pos+1);
-        format->fill_char = READ_spec(pos);
-        fill_char_specified = 1;
-        align_specified = 1;
-        pos += 2;
-    }
-    else if (end-pos >= 1 && is_alignment_token(READ_spec(pos))) {
-        format->align = READ_spec(pos);
-        align_specified = 1;
-        ++pos;
-    }
-
-    /* Parse the various sign options */
-    if (end-pos >= 1 && is_sign_element(READ_spec(pos))) {
-        format->sign = READ_spec(pos);
-        ++pos;
-    }
-
-    /* If the next character is #, we're in alternate mode.  This only
-       applies to integers. */
-    if (end-pos >= 1 && READ_spec(pos) == '#') {
-        format->alternate = 1;
-        ++pos;
-    }
-
-    /* The special case for 0-padding (backwards compat) */
-    if (!fill_char_specified && end-pos >= 1 && READ_spec(pos) == '0') {
-        format->fill_char = '0';
-        if (!align_specified) {
-            format->align = '=';
-        }
-        ++pos;
-    }
-
-    consumed = get_integer(format_spec, &pos, end, &format->width);
-    if (consumed == -1)
-        /* Overflow error. Exception already set. */
-        return 0;
-
-    /* If consumed is 0, we didn't consume any characters for the
-       width. In that case, reset the width to -1, because
-       get_integer() will have set it to zero. -1 is how we record
-       that the width wasn't specified. */
-    if (consumed == 0)
-        format->width = -1;
-
-    /* Comma signifies add thousands separators */
-    if (end-pos && READ_spec(pos) == ',') {
-        format->thousands_separators = LT_DEFAULT_LOCALE;
-        ++pos;
-    }
-    /* Underscore signifies add thousands separators */
-    if (end-pos && READ_spec(pos) == '_') {
-        if (format->thousands_separators != LT_NO_LOCALE) {
-            invalid_comma_and_underscore();
-            return 0;
-        }
-        format->thousands_separators = LT_UNDERSCORE_LOCALE;
-        ++pos;
-    }
-    if (end-pos && READ_spec(pos) == ',') {
+    /* end-pos is used throughout this code to specify the length of 
+       the input string */ 
+#define READ_spec(index) PyUnicode_READ(kind, data, index) 
+ 
+    Py_ssize_t consumed; 
+    int align_specified = 0; 
+    int fill_char_specified = 0; 
+ 
+    format->fill_char = ' '; 
+    format->align = default_align; 
+    format->alternate = 0; 
+    format->sign = '\0'; 
+    format->width = -1; 
+    format->thousands_separators = LT_NO_LOCALE; 
+    format->precision = -1; 
+    format->type = default_type; 
+ 
+    /* If the second char is an alignment token, 
+       then parse the fill char */ 
+    if (end-pos >= 2 && is_alignment_token(READ_spec(pos+1))) { 
+        format->align = READ_spec(pos+1); 
+        format->fill_char = READ_spec(pos); 
+        fill_char_specified = 1; 
+        align_specified = 1; 
+        pos += 2; 
+    } 
+    else if (end-pos >= 1 && is_alignment_token(READ_spec(pos))) { 
+        format->align = READ_spec(pos); 
+        align_specified = 1; 
+        ++pos; 
+    } 
+ 
+    /* Parse the various sign options */ 
+    if (end-pos >= 1 && is_sign_element(READ_spec(pos))) { 
+        format->sign = READ_spec(pos); 
+        ++pos; 
+    } 
+ 
+    /* If the next character is #, we're in alternate mode.  This only 
+       applies to integers. */ 
+    if (end-pos >= 1 && READ_spec(pos) == '#') { 
+        format->alternate = 1; 
+        ++pos; 
+    } 
+ 
+    /* The special case for 0-padding (backwards compat) */ 
+    if (!fill_char_specified && end-pos >= 1 && READ_spec(pos) == '0') { 
+        format->fill_char = '0'; 
+        if (!align_specified) { 
+            format->align = '='; 
+        } 
+        ++pos; 
+    } 
+ 
+    consumed = get_integer(format_spec, &pos, end, &format->width); 
+    if (consumed == -1) 
+        /* Overflow error. Exception already set. */ 
+        return 0; 
+ 
+    /* If consumed is 0, we didn't consume any characters for the 
+       width. In that case, reset the width to -1, because 
+       get_integer() will have set it to zero. -1 is how we record 
+       that the width wasn't specified. */ 
+    if (consumed == 0) 
+        format->width = -1; 
+ 
+    /* Comma signifies add thousands separators */ 
+    if (end-pos && READ_spec(pos) == ',') { 
+        format->thousands_separators = LT_DEFAULT_LOCALE; 
+        ++pos; 
+    } 
+    /* Underscore signifies add thousands separators */ 
+    if (end-pos && READ_spec(pos) == '_') { 
+        if (format->thousands_separators != LT_NO_LOCALE) { 
+            invalid_comma_and_underscore(); 
+            return 0; 
+        } 
+        format->thousands_separators = LT_UNDERSCORE_LOCALE; 
+        ++pos; 
+    } 
+    if (end-pos && READ_spec(pos) == ',') { 
         if (format->thousands_separators == LT_UNDERSCORE_LOCALE) {
             invalid_comma_and_underscore();
             return 0;
         }
-    }
-
-    /* Parse field precision */
-    if (end-pos && READ_spec(pos) == '.') {
-        ++pos;
-
-        consumed = get_integer(format_spec, &pos, end, &format->precision);
-        if (consumed == -1)
-            /* Overflow error. Exception already set. */
-            return 0;
-
-        /* Not having a precision after a dot is an error. */
-        if (consumed == 0) {
-            PyErr_Format(PyExc_ValueError,
-                         "Format specifier missing precision");
-            return 0;
-        }
-
-    }
-
-    /* Finally, parse the type field. */
-
-    if (end-pos > 1) {
-        /* More than one char remain, invalid format specifier. */
-        PyErr_Format(PyExc_ValueError, "Invalid format specifier");
-        return 0;
-    }
-
-    if (end-pos == 1) {
-        format->type = READ_spec(pos);
-        ++pos;
-    }
-
-    /* Do as much validating as we can, just by looking at the format
-       specifier.  Do not take into account what type of formatting
-       we're doing (int, float, string). */
-
-    if (format->thousands_separators) {
-        switch (format->type) {
-        case 'd':
-        case 'e':
-        case 'f':
-        case 'g':
-        case 'E':
-        case 'G':
-        case '%':
-        case 'F':
-        case '\0':
-            /* These are allowed. See PEP 378.*/
-            break;
-        case 'b':
-        case 'o':
-        case 'x':
-        case 'X':
-            /* Underscores are allowed in bin/oct/hex. See PEP 515. */
-            if (format->thousands_separators == LT_UNDERSCORE_LOCALE) {
-                /* Every four digits, not every three, in bin/oct/hex. */
-                format->thousands_separators = LT_UNDER_FOUR_LOCALE;
-                break;
-            }
-            /* fall through */
-        default:
-            invalid_thousands_separator_type(format->thousands_separators, format->type);
-            return 0;
-        }
-    }
-
-    assert (format->align <= 127);
-    assert (format->sign <= 127);
-    return 1;
-}
-
-/* Calculate the padding needed. */
-static void
-calc_padding(Py_ssize_t nchars, Py_ssize_t width, Py_UCS4 align,
-             Py_ssize_t *n_lpadding, Py_ssize_t *n_rpadding,
-             Py_ssize_t *n_total)
-{
-    if (width >= 0) {
-        if (nchars > width)
-            *n_total = nchars;
-        else
-            *n_total = width;
-    }
-    else {
-        /* not specified, use all of the chars and no more */
-        *n_total = nchars;
-    }
-
-    /* Figure out how much leading space we need, based on the
-       aligning */
-    if (align == '>')
-        *n_lpadding = *n_total - nchars;
-    else if (align == '^')
-        *n_lpadding = (*n_total - nchars) / 2;
-    else if (align == '<' || align == '=')
-        *n_lpadding = 0;
-    else {
-        /* We should never have an unspecified alignment. */
-        Py_UNREACHABLE();
-    }
-
-    *n_rpadding = *n_total - nchars - *n_lpadding;
-}
-
-/* Do the padding, and return a pointer to where the caller-supplied
-   content goes. */
-static int
-fill_padding(_PyUnicodeWriter *writer,
-             Py_ssize_t nchars,
-             Py_UCS4 fill_char, Py_ssize_t n_lpadding,
-             Py_ssize_t n_rpadding)
-{
-    Py_ssize_t pos;
-
-    /* Pad on left. */
-    if (n_lpadding) {
-        pos = writer->pos;
-        _PyUnicode_FastFill(writer->buffer, pos, n_lpadding, fill_char);
-    }
-
-    /* Pad on right. */
-    if (n_rpadding) {
-        pos = writer->pos + nchars + n_lpadding;
-        _PyUnicode_FastFill(writer->buffer, pos, n_rpadding, fill_char);
-    }
-
-    /* Pointer to the user content. */
-    writer->pos += n_lpadding;
-    return 0;
-}
-
-/************************************************************************/
-/*********** common routines for numeric formatting *********************/
-/************************************************************************/
-
-/* Locale info needed for formatting integers and the part of floats
-   before and including the decimal. Note that locales only support
-   8-bit chars, not unicode. */
-typedef struct {
-    PyObject *decimal_point;
-    PyObject *thousands_sep;
-    const char *grouping;
-    char *grouping_buffer;
-} LocaleInfo;
-
+    } 
+ 
+    /* Parse field precision */ 
+    if (end-pos && READ_spec(pos) == '.') { 
+        ++pos; 
+ 
+        consumed = get_integer(format_spec, &pos, end, &format->precision); 
+        if (consumed == -1) 
+            /* Overflow error. Exception already set. */ 
+            return 0; 
+ 
+        /* Not having a precision after a dot is an error. */ 
+        if (consumed == 0) { 
+            PyErr_Format(PyExc_ValueError, 
+                         "Format specifier missing precision"); 
+            return 0; 
+        } 
+ 
+    } 
+ 
+    /* Finally, parse the type field. */ 
+ 
+    if (end-pos > 1) { 
+        /* More than one char remain, invalid format specifier. */ 
+        PyErr_Format(PyExc_ValueError, "Invalid format specifier"); 
+        return 0; 
+    } 
+ 
+    if (end-pos == 1) { 
+        format->type = READ_spec(pos); 
+        ++pos; 
+    } 
+ 
+    /* Do as much validating as we can, just by looking at the format 
+       specifier.  Do not take into account what type of formatting 
+       we're doing (int, float, string). */ 
+ 
+    if (format->thousands_separators) { 
+        switch (format->type) { 
+        case 'd': 
+        case 'e': 
+        case 'f': 
+        case 'g': 
+        case 'E': 
+        case 'G': 
+        case '%': 
+        case 'F': 
+        case '\0': 
+            /* These are allowed. See PEP 378.*/ 
+            break; 
+        case 'b': 
+        case 'o': 
+        case 'x': 
+        case 'X': 
+            /* Underscores are allowed in bin/oct/hex. See PEP 515. */ 
+            if (format->thousands_separators == LT_UNDERSCORE_LOCALE) { 
+                /* Every four digits, not every three, in bin/oct/hex. */ 
+                format->thousands_separators = LT_UNDER_FOUR_LOCALE; 
+                break; 
+            } 
+            /* fall through */ 
+        default: 
+            invalid_thousands_separator_type(format->thousands_separators, format->type); 
+            return 0; 
+        } 
+    } 
+ 
+    assert (format->align <= 127); 
+    assert (format->sign <= 127); 
+    return 1; 
+} 
+ 
+/* Calculate the padding needed. */ 
+static void 
+calc_padding(Py_ssize_t nchars, Py_ssize_t width, Py_UCS4 align, 
+             Py_ssize_t *n_lpadding, Py_ssize_t *n_rpadding, 
+             Py_ssize_t *n_total) 
+{ 
+    if (width >= 0) { 
+        if (nchars > width) 
+            *n_total = nchars; 
+        else 
+            *n_total = width; 
+    } 
+    else { 
+        /* not specified, use all of the chars and no more */ 
+        *n_total = nchars; 
+    } 
+ 
+    /* Figure out how much leading space we need, based on the 
+       aligning */ 
+    if (align == '>') 
+        *n_lpadding = *n_total - nchars; 
+    else if (align == '^') 
+        *n_lpadding = (*n_total - nchars) / 2; 
+    else if (align == '<' || align == '=') 
+        *n_lpadding = 0; 
+    else { 
+        /* We should never have an unspecified alignment. */ 
+        Py_UNREACHABLE(); 
+    } 
+ 
+    *n_rpadding = *n_total - nchars - *n_lpadding; 
+} 
+ 
+/* Do the padding, and return a pointer to where the caller-supplied 
+   content goes. */ 
+static int 
+fill_padding(_PyUnicodeWriter *writer, 
+             Py_ssize_t nchars, 
+             Py_UCS4 fill_char, Py_ssize_t n_lpadding, 
+             Py_ssize_t n_rpadding) 
+{ 
+    Py_ssize_t pos; 
+ 
+    /* Pad on left. */ 
+    if (n_lpadding) { 
+        pos = writer->pos; 
+        _PyUnicode_FastFill(writer->buffer, pos, n_lpadding, fill_char); 
+    } 
+ 
+    /* Pad on right. */ 
+    if (n_rpadding) { 
+        pos = writer->pos + nchars + n_lpadding; 
+        _PyUnicode_FastFill(writer->buffer, pos, n_rpadding, fill_char); 
+    } 
+ 
+    /* Pointer to the user content. */ 
+    writer->pos += n_lpadding; 
+    return 0; 
+} 
+ 
+/************************************************************************/ 
+/*********** common routines for numeric formatting *********************/ 
+/************************************************************************/ 
+ 
+/* Locale info needed for formatting integers and the part of floats 
+   before and including the decimal. Note that locales only support 
+   8-bit chars, not unicode. */ 
+typedef struct { 
+    PyObject *decimal_point; 
+    PyObject *thousands_sep; 
+    const char *grouping; 
+    char *grouping_buffer; 
+} LocaleInfo; 
+ 
 #define LocaleInfo_STATIC_INIT {0, 0, 0, 0}
-
-/* describes the layout for an integer, see the comment in
-   calc_number_widths() for details */
-typedef struct {
-    Py_ssize_t n_lpadding;
-    Py_ssize_t n_prefix;
-    Py_ssize_t n_spadding;
-    Py_ssize_t n_rpadding;
-    char sign;
-    Py_ssize_t n_sign;      /* number of digits needed for sign (0/1) */
-    Py_ssize_t n_grouped_digits; /* Space taken up by the digits, including
-                                    any grouping chars. */
-    Py_ssize_t n_decimal;   /* 0 if only an integer */
-    Py_ssize_t n_remainder; /* Digits in decimal and/or exponent part,
-                               excluding the decimal itself, if
-                               present. */
-
-    /* These 2 are not the widths of fields, but are needed by
-       STRINGLIB_GROUPING. */
-    Py_ssize_t n_digits;    /* The number of digits before a decimal
-                               or exponent. */
-    Py_ssize_t n_min_width; /* The min_width we used when we computed
-                               the n_grouped_digits width. */
-} NumberFieldWidths;
-
-
-/* Given a number of the form:
-   digits[remainder]
-   where ptr points to the start and end points to the end, find where
-    the integer part ends. This could be a decimal, an exponent, both,
-    or neither.
-   If a decimal point is present, set *has_decimal and increment
-    remainder beyond it.
-   Results are undefined (but shouldn't crash) for improperly
-    formatted strings.
-*/
-static void
-parse_number(PyObject *s, Py_ssize_t pos, Py_ssize_t end,
-             Py_ssize_t *n_remainder, int *has_decimal)
-{
-    Py_ssize_t remainder;
-    int kind = PyUnicode_KIND(s);
+ 
+/* describes the layout for an integer, see the comment in 
+   calc_number_widths() for details */ 
+typedef struct { 
+    Py_ssize_t n_lpadding; 
+    Py_ssize_t n_prefix; 
+    Py_ssize_t n_spadding; 
+    Py_ssize_t n_rpadding; 
+    char sign; 
+    Py_ssize_t n_sign;      /* number of digits needed for sign (0/1) */ 
+    Py_ssize_t n_grouped_digits; /* Space taken up by the digits, including 
+                                    any grouping chars. */ 
+    Py_ssize_t n_decimal;   /* 0 if only an integer */ 
+    Py_ssize_t n_remainder; /* Digits in decimal and/or exponent part, 
+                               excluding the decimal itself, if 
+                               present. */ 
+ 
+    /* These 2 are not the widths of fields, but are needed by 
+       STRINGLIB_GROUPING. */ 
+    Py_ssize_t n_digits;    /* The number of digits before a decimal 
+                               or exponent. */ 
+    Py_ssize_t n_min_width; /* The min_width we used when we computed 
+                               the n_grouped_digits width. */ 
+} NumberFieldWidths; 
+ 
+ 
+/* Given a number of the form: 
+   digits[remainder] 
+   where ptr points to the start and end points to the end, find where 
+    the integer part ends. This could be a decimal, an exponent, both, 
+    or neither. 
+   If a decimal point is present, set *has_decimal and increment 
+    remainder beyond it. 
+   Results are undefined (but shouldn't crash) for improperly 
+    formatted strings. 
+*/ 
+static void 
+parse_number(PyObject *s, Py_ssize_t pos, Py_ssize_t end, 
+             Py_ssize_t *n_remainder, int *has_decimal) 
+{ 
+    Py_ssize_t remainder; 
+    int kind = PyUnicode_KIND(s); 
     const void *data = PyUnicode_DATA(s);
-
-    while (pos<end && Py_ISDIGIT(PyUnicode_READ(kind, data, pos)))
-        ++pos;
-    remainder = pos;
-
-    /* Does remainder start with a decimal point? */
-    *has_decimal = pos<end && PyUnicode_READ(kind, data, remainder) == '.';
-
-    /* Skip the decimal point. */
-    if (*has_decimal)
-        remainder++;
-
-    *n_remainder = end - remainder;
-}
-
-/* not all fields of format are used.  for example, precision is
-   unused.  should this take discrete params in order to be more clear
-   about what it does?  or is passing a single format parameter easier
-   and more efficient enough to justify a little obfuscation?
-   Return -1 on error. */
-static Py_ssize_t
-calc_number_widths(NumberFieldWidths *spec, Py_ssize_t n_prefix,
+ 
+    while (pos<end && Py_ISDIGIT(PyUnicode_READ(kind, data, pos))) 
+        ++pos; 
+    remainder = pos; 
+ 
+    /* Does remainder start with a decimal point? */ 
+    *has_decimal = pos<end && PyUnicode_READ(kind, data, remainder) == '.'; 
+ 
+    /* Skip the decimal point. */ 
+    if (*has_decimal) 
+        remainder++; 
+ 
+    *n_remainder = end - remainder; 
+} 
+ 
+/* not all fields of format are used.  for example, precision is 
+   unused.  should this take discrete params in order to be more clear 
+   about what it does?  or is passing a single format parameter easier 
+   and more efficient enough to justify a little obfuscation? 
+   Return -1 on error. */ 
+static Py_ssize_t 
+calc_number_widths(NumberFieldWidths *spec, Py_ssize_t n_prefix, 
                    Py_UCS4 sign_char, Py_ssize_t n_start,
-                   Py_ssize_t n_end, Py_ssize_t n_remainder,
-                   int has_decimal, const LocaleInfo *locale,
-                   const InternalFormatSpec *format, Py_UCS4 *maxchar)
-{
-    Py_ssize_t n_non_digit_non_padding;
-    Py_ssize_t n_padding;
-
-    spec->n_digits = n_end - n_start - n_remainder - (has_decimal?1:0);
-    spec->n_lpadding = 0;
-    spec->n_prefix = n_prefix;
-    spec->n_decimal = has_decimal ? PyUnicode_GET_LENGTH(locale->decimal_point) : 0;
-    spec->n_remainder = n_remainder;
-    spec->n_spadding = 0;
-    spec->n_rpadding = 0;
-    spec->sign = '\0';
-    spec->n_sign = 0;
-
-    /* the output will look like:
-       |                                                                                         |
-       | <lpadding> <sign> <prefix> <spadding> <grouped_digits> <decimal> <remainder> <rpadding> |
-       |                                                                                         |
-
-       sign is computed from format->sign and the actual
-       sign of the number
-
-       prefix is given (it's for the '0x' prefix)
-
-       digits is already known
-
-       the total width is either given, or computed from the
-       actual digits
-
-       only one of lpadding, spadding, and rpadding can be non-zero,
-       and it's calculated from the width and other fields
-    */
-
-    /* compute the various parts we're going to write */
-    switch (format->sign) {
-    case '+':
-        /* always put a + or - */
-        spec->n_sign = 1;
-        spec->sign = (sign_char == '-' ? '-' : '+');
-        break;
-    case ' ':
-        spec->n_sign = 1;
-        spec->sign = (sign_char == '-' ? '-' : ' ');
-        break;
-    default:
-        /* Not specified, or the default (-) */
-        if (sign_char == '-') {
-            spec->n_sign = 1;
-            spec->sign = '-';
-        }
-    }
-
-    /* The number of chars used for non-digits and non-padding. */
-    n_non_digit_non_padding = spec->n_sign + spec->n_prefix + spec->n_decimal +
-        spec->n_remainder;
-
-    /* min_width can go negative, that's okay. format->width == -1 means
-       we don't care. */
-    if (format->fill_char == '0' && format->align == '=')
-        spec->n_min_width = format->width - n_non_digit_non_padding;
-    else
-        spec->n_min_width = 0;
-
-    if (spec->n_digits == 0)
-        /* This case only occurs when using 'c' formatting, we need
-           to special case it because the grouping code always wants
-           to have at least one character. */
-        spec->n_grouped_digits = 0;
-    else {
-        Py_UCS4 grouping_maxchar;
-        spec->n_grouped_digits = _PyUnicode_InsertThousandsGrouping(
-            NULL, 0,
-            NULL, 0, spec->n_digits,
-            spec->n_min_width,
-            locale->grouping, locale->thousands_sep, &grouping_maxchar);
-        if (spec->n_grouped_digits == -1) {
-            return -1;
-        }
-        *maxchar = Py_MAX(*maxchar, grouping_maxchar);
-    }
-
-    /* Given the desired width and the total of digit and non-digit
-       space we consume, see if we need any padding. format->width can
-       be negative (meaning no padding), but this code still works in
-       that case. */
-    n_padding = format->width -
-                        (n_non_digit_non_padding + spec->n_grouped_digits);
-    if (n_padding > 0) {
-        /* Some padding is needed. Determine if it's left, space, or right. */
-        switch (format->align) {
-        case '<':
-            spec->n_rpadding = n_padding;
-            break;
-        case '^':
-            spec->n_lpadding = n_padding / 2;
-            spec->n_rpadding = n_padding - spec->n_lpadding;
-            break;
-        case '=':
-            spec->n_spadding = n_padding;
-            break;
-        case '>':
-            spec->n_lpadding = n_padding;
-            break;
-        default:
+                   Py_ssize_t n_end, Py_ssize_t n_remainder, 
+                   int has_decimal, const LocaleInfo *locale, 
+                   const InternalFormatSpec *format, Py_UCS4 *maxchar) 
+{ 
+    Py_ssize_t n_non_digit_non_padding; 
+    Py_ssize_t n_padding; 
+ 
+    spec->n_digits = n_end - n_start - n_remainder - (has_decimal?1:0); 
+    spec->n_lpadding = 0; 
+    spec->n_prefix = n_prefix; 
+    spec->n_decimal = has_decimal ? PyUnicode_GET_LENGTH(locale->decimal_point) : 0; 
+    spec->n_remainder = n_remainder; 
+    spec->n_spadding = 0; 
+    spec->n_rpadding = 0; 
+    spec->sign = '\0'; 
+    spec->n_sign = 0; 
+ 
+    /* the output will look like: 
+       |                                                                                         | 
+       | <lpadding> <sign> <prefix> <spadding> <grouped_digits> <decimal> <remainder> <rpadding> | 
+       |                                                                                         | 
+ 
+       sign is computed from format->sign and the actual 
+       sign of the number 
+ 
+       prefix is given (it's for the '0x' prefix) 
+ 
+       digits is already known 
+ 
+       the total width is either given, or computed from the 
+       actual digits 
+ 
+       only one of lpadding, spadding, and rpadding can be non-zero, 
+       and it's calculated from the width and other fields 
+    */ 
+ 
+    /* compute the various parts we're going to write */ 
+    switch (format->sign) { 
+    case '+': 
+        /* always put a + or - */ 
+        spec->n_sign = 1; 
+        spec->sign = (sign_char == '-' ? '-' : '+'); 
+        break; 
+    case ' ': 
+        spec->n_sign = 1; 
+        spec->sign = (sign_char == '-' ? '-' : ' '); 
+        break; 
+    default: 
+        /* Not specified, or the default (-) */ 
+        if (sign_char == '-') { 
+            spec->n_sign = 1; 
+            spec->sign = '-'; 
+        } 
+    } 
+ 
+    /* The number of chars used for non-digits and non-padding. */ 
+    n_non_digit_non_padding = spec->n_sign + spec->n_prefix + spec->n_decimal + 
+        spec->n_remainder; 
+ 
+    /* min_width can go negative, that's okay. format->width == -1 means 
+       we don't care. */ 
+    if (format->fill_char == '0' && format->align == '=') 
+        spec->n_min_width = format->width - n_non_digit_non_padding; 
+    else 
+        spec->n_min_width = 0; 
+ 
+    if (spec->n_digits == 0) 
+        /* This case only occurs when using 'c' formatting, we need 
+           to special case it because the grouping code always wants 
+           to have at least one character. */ 
+        spec->n_grouped_digits = 0; 
+    else { 
+        Py_UCS4 grouping_maxchar; 
+        spec->n_grouped_digits = _PyUnicode_InsertThousandsGrouping( 
+            NULL, 0, 
+            NULL, 0, spec->n_digits, 
+            spec->n_min_width, 
+            locale->grouping, locale->thousands_sep, &grouping_maxchar); 
+        if (spec->n_grouped_digits == -1) { 
+            return -1; 
+        } 
+        *maxchar = Py_MAX(*maxchar, grouping_maxchar); 
+    } 
+ 
+    /* Given the desired width and the total of digit and non-digit 
+       space we consume, see if we need any padding. format->width can 
+       be negative (meaning no padding), but this code still works in 
+       that case. */ 
+    n_padding = format->width - 
+                        (n_non_digit_non_padding + spec->n_grouped_digits); 
+    if (n_padding > 0) { 
+        /* Some padding is needed. Determine if it's left, space, or right. */ 
+        switch (format->align) { 
+        case '<': 
+            spec->n_rpadding = n_padding; 
+            break; 
+        case '^': 
+            spec->n_lpadding = n_padding / 2; 
+            spec->n_rpadding = n_padding - spec->n_lpadding; 
+            break; 
+        case '=': 
+            spec->n_spadding = n_padding; 
+            break; 
+        case '>': 
+            spec->n_lpadding = n_padding; 
+            break; 
+        default: 
             /* Shouldn't get here */
-            Py_UNREACHABLE();
-        }
-    }
-
-    if (spec->n_lpadding || spec->n_spadding || spec->n_rpadding)
-        *maxchar = Py_MAX(*maxchar, format->fill_char);
-
-    if (spec->n_decimal)
-        *maxchar = Py_MAX(*maxchar, PyUnicode_MAX_CHAR_VALUE(locale->decimal_point));
-
-    return spec->n_lpadding + spec->n_sign + spec->n_prefix +
-        spec->n_spadding + spec->n_grouped_digits + spec->n_decimal +
-        spec->n_remainder + spec->n_rpadding;
-}
-
+            Py_UNREACHABLE(); 
+        } 
+    } 
+ 
+    if (spec->n_lpadding || spec->n_spadding || spec->n_rpadding) 
+        *maxchar = Py_MAX(*maxchar, format->fill_char); 
+ 
+    if (spec->n_decimal) 
+        *maxchar = Py_MAX(*maxchar, PyUnicode_MAX_CHAR_VALUE(locale->decimal_point)); 
+ 
+    return spec->n_lpadding + spec->n_sign + spec->n_prefix + 
+        spec->n_spadding + spec->n_grouped_digits + spec->n_decimal + 
+        spec->n_remainder + spec->n_rpadding; 
+} 
+ 
 /* Fill in the digit parts of a number's string representation,
-   as determined in calc_number_widths().
-   Return -1 on error, or 0 on success. */
-static int
-fill_number(_PyUnicodeWriter *writer, const NumberFieldWidths *spec,
+   as determined in calc_number_widths(). 
+   Return -1 on error, or 0 on success. */ 
+static int 
+fill_number(_PyUnicodeWriter *writer, const NumberFieldWidths *spec, 
             PyObject *digits, Py_ssize_t d_start,
-            PyObject *prefix, Py_ssize_t p_start,
-            Py_UCS4 fill_char,
-            LocaleInfo *locale, int toupper)
-{
-    /* Used to keep track of digits, decimal, and remainder. */
-    Py_ssize_t d_pos = d_start;
-    const unsigned int kind = writer->kind;
-    const void *data = writer->data;
-    Py_ssize_t r;
-
-    if (spec->n_lpadding) {
-        _PyUnicode_FastFill(writer->buffer,
-                            writer->pos, spec->n_lpadding, fill_char);
-        writer->pos += spec->n_lpadding;
-    }
-    if (spec->n_sign == 1) {
-        PyUnicode_WRITE(kind, data, writer->pos, spec->sign);
-        writer->pos++;
-    }
-    if (spec->n_prefix) {
-        _PyUnicode_FastCopyCharacters(writer->buffer, writer->pos,
-                                      prefix, p_start,
-                                      spec->n_prefix);
-        if (toupper) {
-            Py_ssize_t t;
-            for (t = 0; t < spec->n_prefix; t++) {
-                Py_UCS4 c = PyUnicode_READ(kind, data, writer->pos + t);
-                c = Py_TOUPPER(c);
-                assert (c <= 127);
-                PyUnicode_WRITE(kind, data, writer->pos + t, c);
-            }
-        }
-        writer->pos += spec->n_prefix;
-    }
-    if (spec->n_spadding) {
-        _PyUnicode_FastFill(writer->buffer,
-                            writer->pos, spec->n_spadding, fill_char);
-        writer->pos += spec->n_spadding;
-    }
-
-    /* Only for type 'c' special case, it has no digits. */
-    if (spec->n_digits != 0) {
-        /* Fill the digits with InsertThousandsGrouping. */
-        r = _PyUnicode_InsertThousandsGrouping(
-                writer, spec->n_grouped_digits,
-                digits, d_pos, spec->n_digits,
-                spec->n_min_width,
-                locale->grouping, locale->thousands_sep, NULL);
-        if (r == -1)
-            return -1;
-        assert(r == spec->n_grouped_digits);
-        d_pos += spec->n_digits;
-    }
-    if (toupper) {
-        Py_ssize_t t;
-        for (t = 0; t < spec->n_grouped_digits; t++) {
-            Py_UCS4 c = PyUnicode_READ(kind, data, writer->pos + t);
-            c = Py_TOUPPER(c);
-            if (c > 127) {
-                PyErr_SetString(PyExc_SystemError, "non-ascii grouped digit");
-                return -1;
-            }
-            PyUnicode_WRITE(kind, data, writer->pos + t, c);
-        }
-    }
-    writer->pos += spec->n_grouped_digits;
-
-    if (spec->n_decimal) {
-        _PyUnicode_FastCopyCharacters(
-            writer->buffer, writer->pos,
-            locale->decimal_point, 0, spec->n_decimal);
-        writer->pos += spec->n_decimal;
-        d_pos += 1;
-    }
-
-    if (spec->n_remainder) {
-        _PyUnicode_FastCopyCharacters(
-            writer->buffer, writer->pos,
-            digits, d_pos, spec->n_remainder);
-        writer->pos += spec->n_remainder;
-        /* d_pos += spec->n_remainder; */
-    }
-
-    if (spec->n_rpadding) {
-        _PyUnicode_FastFill(writer->buffer,
-                            writer->pos, spec->n_rpadding,
-                            fill_char);
-        writer->pos += spec->n_rpadding;
-    }
-    return 0;
-}
-
-static const char no_grouping[1] = {CHAR_MAX};
-
-/* Find the decimal point character(s?), thousands_separator(s?), and
-   grouping description, either for the current locale if type is
-   LT_CURRENT_LOCALE, a hard-coded locale if LT_DEFAULT_LOCALE or
-   LT_UNDERSCORE_LOCALE/LT_UNDER_FOUR_LOCALE, or none if LT_NO_LOCALE. */
-static int
-get_locale_info(enum LocaleType type, LocaleInfo *locale_info)
-{
-    switch (type) {
-    case LT_CURRENT_LOCALE: {
+            PyObject *prefix, Py_ssize_t p_start, 
+            Py_UCS4 fill_char, 
+            LocaleInfo *locale, int toupper) 
+{ 
+    /* Used to keep track of digits, decimal, and remainder. */ 
+    Py_ssize_t d_pos = d_start; 
+    const unsigned int kind = writer->kind; 
+    const void *data = writer->data; 
+    Py_ssize_t r; 
+ 
+    if (spec->n_lpadding) { 
+        _PyUnicode_FastFill(writer->buffer, 
+                            writer->pos, spec->n_lpadding, fill_char); 
+        writer->pos += spec->n_lpadding; 
+    } 
+    if (spec->n_sign == 1) { 
+        PyUnicode_WRITE(kind, data, writer->pos, spec->sign); 
+        writer->pos++; 
+    } 
+    if (spec->n_prefix) { 
+        _PyUnicode_FastCopyCharacters(writer->buffer, writer->pos, 
+                                      prefix, p_start, 
+                                      spec->n_prefix); 
+        if (toupper) { 
+            Py_ssize_t t; 
+            for (t = 0; t < spec->n_prefix; t++) { 
+                Py_UCS4 c = PyUnicode_READ(kind, data, writer->pos + t); 
+                c = Py_TOUPPER(c); 
+                assert (c <= 127); 
+                PyUnicode_WRITE(kind, data, writer->pos + t, c); 
+            } 
+        } 
+        writer->pos += spec->n_prefix; 
+    } 
+    if (spec->n_spadding) { 
+        _PyUnicode_FastFill(writer->buffer, 
+                            writer->pos, spec->n_spadding, fill_char); 
+        writer->pos += spec->n_spadding; 
+    } 
+ 
+    /* Only for type 'c' special case, it has no digits. */ 
+    if (spec->n_digits != 0) { 
+        /* Fill the digits with InsertThousandsGrouping. */ 
+        r = _PyUnicode_InsertThousandsGrouping( 
+                writer, spec->n_grouped_digits, 
+                digits, d_pos, spec->n_digits, 
+                spec->n_min_width, 
+                locale->grouping, locale->thousands_sep, NULL); 
+        if (r == -1) 
+            return -1; 
+        assert(r == spec->n_grouped_digits); 
+        d_pos += spec->n_digits; 
+    } 
+    if (toupper) { 
+        Py_ssize_t t; 
+        for (t = 0; t < spec->n_grouped_digits; t++) { 
+            Py_UCS4 c = PyUnicode_READ(kind, data, writer->pos + t); 
+            c = Py_TOUPPER(c); 
+            if (c > 127) { 
+                PyErr_SetString(PyExc_SystemError, "non-ascii grouped digit"); 
+                return -1; 
+            } 
+            PyUnicode_WRITE(kind, data, writer->pos + t, c); 
+        } 
+    } 
+    writer->pos += spec->n_grouped_digits; 
+ 
+    if (spec->n_decimal) { 
+        _PyUnicode_FastCopyCharacters( 
+            writer->buffer, writer->pos, 
+            locale->decimal_point, 0, spec->n_decimal); 
+        writer->pos += spec->n_decimal; 
+        d_pos += 1; 
+    } 
+ 
+    if (spec->n_remainder) { 
+        _PyUnicode_FastCopyCharacters( 
+            writer->buffer, writer->pos, 
+            digits, d_pos, spec->n_remainder); 
+        writer->pos += spec->n_remainder; 
+        /* d_pos += spec->n_remainder; */ 
+    } 
+ 
+    if (spec->n_rpadding) { 
+        _PyUnicode_FastFill(writer->buffer, 
+                            writer->pos, spec->n_rpadding, 
+                            fill_char); 
+        writer->pos += spec->n_rpadding; 
+    } 
+    return 0; 
+} 
+ 
+static const char no_grouping[1] = {CHAR_MAX}; 
+ 
+/* Find the decimal point character(s?), thousands_separator(s?), and 
+   grouping description, either for the current locale if type is 
+   LT_CURRENT_LOCALE, a hard-coded locale if LT_DEFAULT_LOCALE or 
+   LT_UNDERSCORE_LOCALE/LT_UNDER_FOUR_LOCALE, or none if LT_NO_LOCALE. */ 
+static int 
+get_locale_info(enum LocaleType type, LocaleInfo *locale_info) 
+{ 
+    switch (type) { 
+    case LT_CURRENT_LOCALE: { 
         struct lconv *lc = localeconv();
         if (_Py_GetLocaleconvNumeric(lc,
                                      &locale_info->decimal_point,
                                      &locale_info->thousands_sep) < 0) {
-            return -1;
-        }
-
-        /* localeconv() grouping can become a dangling pointer or point
-           to a different string if another thread calls localeconv() during
-           the string formatting. Copy the string to avoid this risk. */
+            return -1; 
+        } 
+ 
+        /* localeconv() grouping can become a dangling pointer or point 
+           to a different string if another thread calls localeconv() during 
+           the string formatting. Copy the string to avoid this risk. */ 
         locale_info->grouping_buffer = _PyMem_Strdup(lc->grouping);
-        if (locale_info->grouping_buffer == NULL) {
-            PyErr_NoMemory();
-            return -1;
-        }
-        locale_info->grouping = locale_info->grouping_buffer;
-        break;
-    }
-    case LT_DEFAULT_LOCALE:
-    case LT_UNDERSCORE_LOCALE:
-    case LT_UNDER_FOUR_LOCALE:
-        locale_info->decimal_point = PyUnicode_FromOrdinal('.');
-        locale_info->thousands_sep = PyUnicode_FromOrdinal(
-            type == LT_DEFAULT_LOCALE ? ',' : '_');
-        if (!locale_info->decimal_point || !locale_info->thousands_sep)
-            return -1;
-        if (type != LT_UNDER_FOUR_LOCALE)
-            locale_info->grouping = "\3"; /* Group every 3 characters.  The
-                                         (implicit) trailing 0 means repeat
-                                         infinitely. */
-        else
-            locale_info->grouping = "\4"; /* Bin/oct/hex group every four. */
-        break;
-    case LT_NO_LOCALE:
-        locale_info->decimal_point = PyUnicode_FromOrdinal('.');
-        locale_info->thousands_sep = PyUnicode_New(0, 0);
-        if (!locale_info->decimal_point || !locale_info->thousands_sep)
-            return -1;
-        locale_info->grouping = no_grouping;
-        break;
-    }
-    return 0;
-}
-
-static void
-free_locale_info(LocaleInfo *locale_info)
-{
-    Py_XDECREF(locale_info->decimal_point);
-    Py_XDECREF(locale_info->thousands_sep);
-    PyMem_Free(locale_info->grouping_buffer);
-}
-
-/************************************************************************/
-/*********** string formatting ******************************************/
-/************************************************************************/
-
-static int
-format_string_internal(PyObject *value, const InternalFormatSpec *format,
-                       _PyUnicodeWriter *writer)
-{
-    Py_ssize_t lpad;
-    Py_ssize_t rpad;
-    Py_ssize_t total;
-    Py_ssize_t len;
-    int result = -1;
-    Py_UCS4 maxchar;
-
-    assert(PyUnicode_IS_READY(value));
-    len = PyUnicode_GET_LENGTH(value);
-
-    /* sign is not allowed on strings */
-    if (format->sign != '\0') {
+        if (locale_info->grouping_buffer == NULL) { 
+            PyErr_NoMemory(); 
+            return -1; 
+        } 
+        locale_info->grouping = locale_info->grouping_buffer; 
+        break; 
+    } 
+    case LT_DEFAULT_LOCALE: 
+    case LT_UNDERSCORE_LOCALE: 
+    case LT_UNDER_FOUR_LOCALE: 
+        locale_info->decimal_point = PyUnicode_FromOrdinal('.'); 
+        locale_info->thousands_sep = PyUnicode_FromOrdinal( 
+            type == LT_DEFAULT_LOCALE ? ',' : '_'); 
+        if (!locale_info->decimal_point || !locale_info->thousands_sep) 
+            return -1; 
+        if (type != LT_UNDER_FOUR_LOCALE) 
+            locale_info->grouping = "\3"; /* Group every 3 characters.  The 
+                                         (implicit) trailing 0 means repeat 
+                                         infinitely. */ 
+        else 
+            locale_info->grouping = "\4"; /* Bin/oct/hex group every four. */ 
+        break; 
+    case LT_NO_LOCALE: 
+        locale_info->decimal_point = PyUnicode_FromOrdinal('.'); 
+        locale_info->thousands_sep = PyUnicode_New(0, 0); 
+        if (!locale_info->decimal_point || !locale_info->thousands_sep) 
+            return -1; 
+        locale_info->grouping = no_grouping; 
+        break; 
+    } 
+    return 0; 
+} 
+ 
+static void 
+free_locale_info(LocaleInfo *locale_info) 
+{ 
+    Py_XDECREF(locale_info->decimal_point); 
+    Py_XDECREF(locale_info->thousands_sep); 
+    PyMem_Free(locale_info->grouping_buffer); 
+} 
+ 
+/************************************************************************/ 
+/*********** string formatting ******************************************/ 
+/************************************************************************/ 
+ 
+static int 
+format_string_internal(PyObject *value, const InternalFormatSpec *format, 
+                       _PyUnicodeWriter *writer) 
+{ 
+    Py_ssize_t lpad; 
+    Py_ssize_t rpad; 
+    Py_ssize_t total; 
+    Py_ssize_t len; 
+    int result = -1; 
+    Py_UCS4 maxchar; 
+ 
+    assert(PyUnicode_IS_READY(value)); 
+    len = PyUnicode_GET_LENGTH(value); 
+ 
+    /* sign is not allowed on strings */ 
+    if (format->sign != '\0') { 
         if (format->sign == ' ') {
             PyErr_SetString(PyExc_ValueError,
                 "Space not allowed in string format specifier");
@@ -781,820 +781,820 @@ format_string_internal(PyObject *value, const InternalFormatSpec *format,
             PyErr_SetString(PyExc_ValueError,
                 "Sign not allowed in string format specifier");
         }
-        goto done;
-    }
-
-    /* alternate is not allowed on strings */
-    if (format->alternate) {
-        PyErr_SetString(PyExc_ValueError,
-                        "Alternate form (#) not allowed in string format "
-                        "specifier");
-        goto done;
-    }
-
-    /* '=' alignment not allowed on strings */
-    if (format->align == '=') {
-        PyErr_SetString(PyExc_ValueError,
-                        "'=' alignment not allowed "
-                        "in string format specifier");
-        goto done;
-    }
-
-    if ((format->width == -1 || format->width <= len)
-        && (format->precision == -1 || format->precision >= len)) {
-        /* Fast path */
-        return _PyUnicodeWriter_WriteStr(writer, value);
-    }
-
-    /* if precision is specified, output no more that format.precision
-       characters */
-    if (format->precision >= 0 && len >= format->precision) {
-        len = format->precision;
-    }
-
-    calc_padding(len, format->width, format->align, &lpad, &rpad, &total);
-
-    maxchar = writer->maxchar;
-    if (lpad != 0 || rpad != 0)
-        maxchar = Py_MAX(maxchar, format->fill_char);
-    if (PyUnicode_MAX_CHAR_VALUE(value) > maxchar) {
-        Py_UCS4 valmaxchar = _PyUnicode_FindMaxChar(value, 0, len);
-        maxchar = Py_MAX(maxchar, valmaxchar);
-    }
-
-    /* allocate the resulting string */
-    if (_PyUnicodeWriter_Prepare(writer, total, maxchar) == -1)
-        goto done;
-
-    /* Write into that space. First the padding. */
-    result = fill_padding(writer, len, format->fill_char, lpad, rpad);
-    if (result == -1)
-        goto done;
-
-    /* Then the source string. */
-    if (len) {
-        _PyUnicode_FastCopyCharacters(writer->buffer, writer->pos,
-                                      value, 0, len);
-    }
-    writer->pos += (len + rpad);
-    result = 0;
-
-done:
-    return result;
-}
-
-
-/************************************************************************/
-/*********** long formatting ********************************************/
-/************************************************************************/
-
-static int
-format_long_internal(PyObject *value, const InternalFormatSpec *format,
-                     _PyUnicodeWriter *writer)
-{
-    int result = -1;
-    Py_UCS4 maxchar = 127;
-    PyObject *tmp = NULL;
-    Py_ssize_t inumeric_chars;
-    Py_UCS4 sign_char = '\0';
-    Py_ssize_t n_digits;       /* count of digits need from the computed
-                                  string */
-    Py_ssize_t n_remainder = 0; /* Used only for 'c' formatting, which
-                                   produces non-digits */
-    Py_ssize_t n_prefix = 0;   /* Count of prefix chars, (e.g., '0x') */
-    Py_ssize_t n_total;
-    Py_ssize_t prefix = 0;
-    NumberFieldWidths spec;
-    long x;
-
-    /* Locale settings, either from the actual locale or
-       from a hard-code pseudo-locale */
+        goto done; 
+    } 
+ 
+    /* alternate is not allowed on strings */ 
+    if (format->alternate) { 
+        PyErr_SetString(PyExc_ValueError, 
+                        "Alternate form (#) not allowed in string format " 
+                        "specifier"); 
+        goto done; 
+    } 
+ 
+    /* '=' alignment not allowed on strings */ 
+    if (format->align == '=') { 
+        PyErr_SetString(PyExc_ValueError, 
+                        "'=' alignment not allowed " 
+                        "in string format specifier"); 
+        goto done; 
+    } 
+ 
+    if ((format->width == -1 || format->width <= len) 
+        && (format->precision == -1 || format->precision >= len)) { 
+        /* Fast path */ 
+        return _PyUnicodeWriter_WriteStr(writer, value); 
+    } 
+ 
+    /* if precision is specified, output no more that format.precision 
+       characters */ 
+    if (format->precision >= 0 && len >= format->precision) { 
+        len = format->precision; 
+    } 
+ 
+    calc_padding(len, format->width, format->align, &lpad, &rpad, &total); 
+ 
+    maxchar = writer->maxchar; 
+    if (lpad != 0 || rpad != 0) 
+        maxchar = Py_MAX(maxchar, format->fill_char); 
+    if (PyUnicode_MAX_CHAR_VALUE(value) > maxchar) { 
+        Py_UCS4 valmaxchar = _PyUnicode_FindMaxChar(value, 0, len); 
+        maxchar = Py_MAX(maxchar, valmaxchar); 
+    } 
+ 
+    /* allocate the resulting string */ 
+    if (_PyUnicodeWriter_Prepare(writer, total, maxchar) == -1) 
+        goto done; 
+ 
+    /* Write into that space. First the padding. */ 
+    result = fill_padding(writer, len, format->fill_char, lpad, rpad); 
+    if (result == -1) 
+        goto done; 
+ 
+    /* Then the source string. */ 
+    if (len) { 
+        _PyUnicode_FastCopyCharacters(writer->buffer, writer->pos, 
+                                      value, 0, len); 
+    } 
+    writer->pos += (len + rpad); 
+    result = 0; 
+ 
+done: 
+    return result; 
+} 
+ 
+ 
+/************************************************************************/ 
+/*********** long formatting ********************************************/ 
+/************************************************************************/ 
+ 
+static int 
+format_long_internal(PyObject *value, const InternalFormatSpec *format, 
+                     _PyUnicodeWriter *writer) 
+{ 
+    int result = -1; 
+    Py_UCS4 maxchar = 127; 
+    PyObject *tmp = NULL; 
+    Py_ssize_t inumeric_chars; 
+    Py_UCS4 sign_char = '\0'; 
+    Py_ssize_t n_digits;       /* count of digits need from the computed 
+                                  string */ 
+    Py_ssize_t n_remainder = 0; /* Used only for 'c' formatting, which 
+                                   produces non-digits */ 
+    Py_ssize_t n_prefix = 0;   /* Count of prefix chars, (e.g., '0x') */ 
+    Py_ssize_t n_total; 
+    Py_ssize_t prefix = 0; 
+    NumberFieldWidths spec; 
+    long x; 
+ 
+    /* Locale settings, either from the actual locale or 
+       from a hard-code pseudo-locale */ 
     LocaleInfo locale = LocaleInfo_STATIC_INIT;
-
-    /* no precision allowed on integers */
-    if (format->precision != -1) {
-        PyErr_SetString(PyExc_ValueError,
-                        "Precision not allowed in integer format specifier");
-        goto done;
-    }
-
-    /* special case for character formatting */
-    if (format->type == 'c') {
-        /* error to specify a sign */
-        if (format->sign != '\0') {
-            PyErr_SetString(PyExc_ValueError,
-                            "Sign not allowed with integer"
-                            " format specifier 'c'");
-            goto done;
-        }
-        /* error to request alternate format */
-        if (format->alternate) {
-            PyErr_SetString(PyExc_ValueError,
-                            "Alternate form (#) not allowed with integer"
-                            " format specifier 'c'");
-            goto done;
-        }
-
-        /* taken from unicodeobject.c formatchar() */
-        /* Integer input truncated to a character */
-        x = PyLong_AsLong(value);
-        if (x == -1 && PyErr_Occurred())
-            goto done;
-        if (x < 0 || x > 0x10ffff) {
-            PyErr_SetString(PyExc_OverflowError,
-                            "%c arg not in range(0x110000)");
-            goto done;
-        }
-        tmp = PyUnicode_FromOrdinal(x);
-        inumeric_chars = 0;
-        n_digits = 1;
-        maxchar = Py_MAX(maxchar, (Py_UCS4)x);
-
-        /* As a sort-of hack, we tell calc_number_widths that we only
-           have "remainder" characters. calc_number_widths thinks
-           these are characters that don't get formatted, only copied
-           into the output string. We do this for 'c' formatting,
-           because the characters are likely to be non-digits. */
-        n_remainder = 1;
-    }
-    else {
-        int base;
-        int leading_chars_to_skip = 0;  /* Number of characters added by
-                                           PyNumber_ToBase that we want to
-                                           skip over. */
-
-        /* Compute the base and how many characters will be added by
-           PyNumber_ToBase */
-        switch (format->type) {
-        case 'b':
-            base = 2;
-            leading_chars_to_skip = 2; /* 0b */
-            break;
-        case 'o':
-            base = 8;
-            leading_chars_to_skip = 2; /* 0o */
-            break;
-        case 'x':
-        case 'X':
-            base = 16;
-            leading_chars_to_skip = 2; /* 0x */
-            break;
-        default:  /* shouldn't be needed, but stops a compiler warning */
-        case 'd':
-        case 'n':
-            base = 10;
-            break;
-        }
-
-        if (format->sign != '+' && format->sign != ' '
-            && format->width == -1
-            && format->type != 'X' && format->type != 'n'
-            && !format->thousands_separators
-            && PyLong_CheckExact(value))
-        {
-            /* Fast path */
-            return _PyLong_FormatWriter(writer, value, base, format->alternate);
-        }
-
-        /* The number of prefix chars is the same as the leading
-           chars to skip */
-        if (format->alternate)
-            n_prefix = leading_chars_to_skip;
-
-        /* Do the hard part, converting to a string in a given base */
-        tmp = _PyLong_Format(value, base);
-        if (tmp == NULL || PyUnicode_READY(tmp) == -1)
-            goto done;
-
-        inumeric_chars = 0;
-        n_digits = PyUnicode_GET_LENGTH(tmp);
-
-        prefix = inumeric_chars;
-
-        /* Is a sign character present in the output?  If so, remember it
-           and skip it */
-        if (PyUnicode_READ_CHAR(tmp, inumeric_chars) == '-') {
-            sign_char = '-';
-            ++prefix;
-            ++leading_chars_to_skip;
-        }
-
-        /* Skip over the leading chars (0x, 0b, etc.) */
-        n_digits -= leading_chars_to_skip;
-        inumeric_chars += leading_chars_to_skip;
-    }
-
-    /* Determine the grouping, separator, and decimal point, if any. */
-    if (get_locale_info(format->type == 'n' ? LT_CURRENT_LOCALE :
-                        format->thousands_separators,
-                        &locale) == -1)
-        goto done;
-
-    /* Calculate how much memory we'll need. */
+ 
+    /* no precision allowed on integers */ 
+    if (format->precision != -1) { 
+        PyErr_SetString(PyExc_ValueError, 
+                        "Precision not allowed in integer format specifier"); 
+        goto done; 
+    } 
+ 
+    /* special case for character formatting */ 
+    if (format->type == 'c') { 
+        /* error to specify a sign */ 
+        if (format->sign != '\0') { 
+            PyErr_SetString(PyExc_ValueError, 
+                            "Sign not allowed with integer" 
+                            " format specifier 'c'"); 
+            goto done; 
+        } 
+        /* error to request alternate format */ 
+        if (format->alternate) { 
+            PyErr_SetString(PyExc_ValueError, 
+                            "Alternate form (#) not allowed with integer" 
+                            " format specifier 'c'"); 
+            goto done; 
+        } 
+ 
+        /* taken from unicodeobject.c formatchar() */ 
+        /* Integer input truncated to a character */ 
+        x = PyLong_AsLong(value); 
+        if (x == -1 && PyErr_Occurred()) 
+            goto done; 
+        if (x < 0 || x > 0x10ffff) { 
+            PyErr_SetString(PyExc_OverflowError, 
+                            "%c arg not in range(0x110000)"); 
+            goto done; 
+        } 
+        tmp = PyUnicode_FromOrdinal(x); 
+        inumeric_chars = 0; 
+        n_digits = 1; 
+        maxchar = Py_MAX(maxchar, (Py_UCS4)x); 
+ 
+        /* As a sort-of hack, we tell calc_number_widths that we only 
+           have "remainder" characters. calc_number_widths thinks 
+           these are characters that don't get formatted, only copied 
+           into the output string. We do this for 'c' formatting, 
+           because the characters are likely to be non-digits. */ 
+        n_remainder = 1; 
+    } 
+    else { 
+        int base; 
+        int leading_chars_to_skip = 0;  /* Number of characters added by 
+                                           PyNumber_ToBase that we want to 
+                                           skip over. */ 
+ 
+        /* Compute the base and how many characters will be added by 
+           PyNumber_ToBase */ 
+        switch (format->type) { 
+        case 'b': 
+            base = 2; 
+            leading_chars_to_skip = 2; /* 0b */ 
+            break; 
+        case 'o': 
+            base = 8; 
+            leading_chars_to_skip = 2; /* 0o */ 
+            break; 
+        case 'x': 
+        case 'X': 
+            base = 16; 
+            leading_chars_to_skip = 2; /* 0x */ 
+            break; 
+        default:  /* shouldn't be needed, but stops a compiler warning */ 
+        case 'd': 
+        case 'n': 
+            base = 10; 
+            break; 
+        } 
+ 
+        if (format->sign != '+' && format->sign != ' ' 
+            && format->width == -1 
+            && format->type != 'X' && format->type != 'n' 
+            && !format->thousands_separators 
+            && PyLong_CheckExact(value)) 
+        { 
+            /* Fast path */ 
+            return _PyLong_FormatWriter(writer, value, base, format->alternate); 
+        } 
+ 
+        /* The number of prefix chars is the same as the leading 
+           chars to skip */ 
+        if (format->alternate) 
+            n_prefix = leading_chars_to_skip; 
+ 
+        /* Do the hard part, converting to a string in a given base */ 
+        tmp = _PyLong_Format(value, base); 
+        if (tmp == NULL || PyUnicode_READY(tmp) == -1) 
+            goto done; 
+ 
+        inumeric_chars = 0; 
+        n_digits = PyUnicode_GET_LENGTH(tmp); 
+ 
+        prefix = inumeric_chars; 
+ 
+        /* Is a sign character present in the output?  If so, remember it 
+           and skip it */ 
+        if (PyUnicode_READ_CHAR(tmp, inumeric_chars) == '-') { 
+            sign_char = '-'; 
+            ++prefix; 
+            ++leading_chars_to_skip; 
+        } 
+ 
+        /* Skip over the leading chars (0x, 0b, etc.) */ 
+        n_digits -= leading_chars_to_skip; 
+        inumeric_chars += leading_chars_to_skip; 
+    } 
+ 
+    /* Determine the grouping, separator, and decimal point, if any. */ 
+    if (get_locale_info(format->type == 'n' ? LT_CURRENT_LOCALE : 
+                        format->thousands_separators, 
+                        &locale) == -1) 
+        goto done; 
+ 
+    /* Calculate how much memory we'll need. */ 
     n_total = calc_number_widths(&spec, n_prefix, sign_char, inumeric_chars,
-                                 inumeric_chars + n_digits, n_remainder, 0,
-                                 &locale, format, &maxchar);
-    if (n_total == -1) {
-        goto done;
-    }
-
-    /* Allocate the memory. */
-    if (_PyUnicodeWriter_Prepare(writer, n_total, maxchar) == -1)
-        goto done;
-
-    /* Populate the memory. */
-    result = fill_number(writer, &spec,
+                                 inumeric_chars + n_digits, n_remainder, 0, 
+                                 &locale, format, &maxchar); 
+    if (n_total == -1) { 
+        goto done; 
+    } 
+ 
+    /* Allocate the memory. */ 
+    if (_PyUnicodeWriter_Prepare(writer, n_total, maxchar) == -1) 
+        goto done; 
+ 
+    /* Populate the memory. */ 
+    result = fill_number(writer, &spec, 
                          tmp, inumeric_chars,
-                         tmp, prefix, format->fill_char,
-                         &locale, format->type == 'X');
-
-done:
-    Py_XDECREF(tmp);
-    free_locale_info(&locale);
-    return result;
-}
-
-/************************************************************************/
-/*********** float formatting *******************************************/
-/************************************************************************/
-
-/* much of this is taken from unicodeobject.c */
-static int
-format_float_internal(PyObject *value,
-                      const InternalFormatSpec *format,
-                      _PyUnicodeWriter *writer)
-{
-    char *buf = NULL;       /* buffer returned from PyOS_double_to_string */
-    Py_ssize_t n_digits;
-    Py_ssize_t n_remainder;
-    Py_ssize_t n_total;
-    int has_decimal;
-    double val;
-    int precision, default_precision = 6;
-    Py_UCS4 type = format->type;
-    int add_pct = 0;
-    Py_ssize_t index;
-    NumberFieldWidths spec;
-    int flags = 0;
-    int result = -1;
-    Py_UCS4 maxchar = 127;
-    Py_UCS4 sign_char = '\0';
-    int float_type; /* Used to see if we have a nan, inf, or regular float. */
-    PyObject *unicode_tmp = NULL;
-
-    /* Locale settings, either from the actual locale or
-       from a hard-code pseudo-locale */
+                         tmp, prefix, format->fill_char, 
+                         &locale, format->type == 'X'); 
+ 
+done: 
+    Py_XDECREF(tmp); 
+    free_locale_info(&locale); 
+    return result; 
+} 
+ 
+/************************************************************************/ 
+/*********** float formatting *******************************************/ 
+/************************************************************************/ 
+ 
+/* much of this is taken from unicodeobject.c */ 
+static int 
+format_float_internal(PyObject *value, 
+                      const InternalFormatSpec *format, 
+                      _PyUnicodeWriter *writer) 
+{ 
+    char *buf = NULL;       /* buffer returned from PyOS_double_to_string */ 
+    Py_ssize_t n_digits; 
+    Py_ssize_t n_remainder; 
+    Py_ssize_t n_total; 
+    int has_decimal; 
+    double val; 
+    int precision, default_precision = 6; 
+    Py_UCS4 type = format->type; 
+    int add_pct = 0; 
+    Py_ssize_t index; 
+    NumberFieldWidths spec; 
+    int flags = 0; 
+    int result = -1; 
+    Py_UCS4 maxchar = 127; 
+    Py_UCS4 sign_char = '\0'; 
+    int float_type; /* Used to see if we have a nan, inf, or regular float. */ 
+    PyObject *unicode_tmp = NULL; 
+ 
+    /* Locale settings, either from the actual locale or 
+       from a hard-code pseudo-locale */ 
     LocaleInfo locale = LocaleInfo_STATIC_INIT;
-
-    if (format->precision > INT_MAX) {
-        PyErr_SetString(PyExc_ValueError, "precision too big");
-        goto done;
-    }
-    precision = (int)format->precision;
-
-    if (format->alternate)
-        flags |= Py_DTSF_ALT;
-
-    if (type == '\0') {
-        /* Omitted type specifier.  Behaves in the same way as repr(x)
-           and str(x) if no precision is given, else like 'g', but with
-           at least one digit after the decimal point. */
-        flags |= Py_DTSF_ADD_DOT_0;
-        type = 'r';
-        default_precision = 0;
-    }
-
-    if (type == 'n')
-        /* 'n' is the same as 'g', except for the locale used to
-           format the result. We take care of that later. */
-        type = 'g';
-
-    val = PyFloat_AsDouble(value);
-    if (val == -1.0 && PyErr_Occurred())
-        goto done;
-
-    if (type == '%') {
-        type = 'f';
-        val *= 100;
-        add_pct = 1;
-    }
-
-    if (precision < 0)
-        precision = default_precision;
-    else if (type == 'r')
-        type = 'g';
-
-    /* Cast "type", because if we're in unicode we need to pass an
-       8-bit char. This is safe, because we've restricted what "type"
-       can be. */
-    buf = PyOS_double_to_string(val, (char)type, precision, flags,
-                                &float_type);
-    if (buf == NULL)
-        goto done;
-    n_digits = strlen(buf);
-
-    if (add_pct) {
-        /* We know that buf has a trailing zero (since we just called
-           strlen() on it), and we don't use that fact any more. So we
-           can just write over the trailing zero. */
-        buf[n_digits] = '%';
-        n_digits += 1;
-    }
-
-    if (format->sign != '+' && format->sign != ' '
-        && format->width == -1
-        && format->type != 'n'
-        && !format->thousands_separators)
-    {
-        /* Fast path */
-        result = _PyUnicodeWriter_WriteASCIIString(writer, buf, n_digits);
-        PyMem_Free(buf);
-        return result;
-    }
-
-    /* Since there is no unicode version of PyOS_double_to_string,
-       just use the 8 bit version and then convert to unicode. */
-    unicode_tmp = _PyUnicode_FromASCII(buf, n_digits);
-    PyMem_Free(buf);
-    if (unicode_tmp == NULL)
-        goto done;
-
-    /* Is a sign character present in the output?  If so, remember it
-       and skip it */
-    index = 0;
-    if (PyUnicode_READ_CHAR(unicode_tmp, index) == '-') {
-        sign_char = '-';
-        ++index;
-        --n_digits;
-    }
-
-    /* Determine if we have any "remainder" (after the digits, might include
-       decimal or exponent or both (or neither)) */
-    parse_number(unicode_tmp, index, index + n_digits, &n_remainder, &has_decimal);
-
-    /* Determine the grouping, separator, and decimal point, if any. */
-    if (get_locale_info(format->type == 'n' ? LT_CURRENT_LOCALE :
-                        format->thousands_separators,
-                        &locale) == -1)
-        goto done;
-
-    /* Calculate how much memory we'll need. */
+ 
+    if (format->precision > INT_MAX) { 
+        PyErr_SetString(PyExc_ValueError, "precision too big"); 
+        goto done; 
+    } 
+    precision = (int)format->precision; 
+ 
+    if (format->alternate) 
+        flags |= Py_DTSF_ALT; 
+ 
+    if (type == '\0') { 
+        /* Omitted type specifier.  Behaves in the same way as repr(x) 
+           and str(x) if no precision is given, else like 'g', but with 
+           at least one digit after the decimal point. */ 
+        flags |= Py_DTSF_ADD_DOT_0; 
+        type = 'r'; 
+        default_precision = 0; 
+    } 
+ 
+    if (type == 'n') 
+        /* 'n' is the same as 'g', except for the locale used to 
+           format the result. We take care of that later. */ 
+        type = 'g'; 
+ 
+    val = PyFloat_AsDouble(value); 
+    if (val == -1.0 && PyErr_Occurred()) 
+        goto done; 
+ 
+    if (type == '%') { 
+        type = 'f'; 
+        val *= 100; 
+        add_pct = 1; 
+    } 
+ 
+    if (precision < 0) 
+        precision = default_precision; 
+    else if (type == 'r') 
+        type = 'g'; 
+ 
+    /* Cast "type", because if we're in unicode we need to pass an 
+       8-bit char. This is safe, because we've restricted what "type" 
+       can be. */ 
+    buf = PyOS_double_to_string(val, (char)type, precision, flags, 
+                                &float_type); 
+    if (buf == NULL) 
+        goto done; 
+    n_digits = strlen(buf); 
+ 
+    if (add_pct) { 
+        /* We know that buf has a trailing zero (since we just called 
+           strlen() on it), and we don't use that fact any more. So we 
+           can just write over the trailing zero. */ 
+        buf[n_digits] = '%'; 
+        n_digits += 1; 
+    } 
+ 
+    if (format->sign != '+' && format->sign != ' ' 
+        && format->width == -1 
+        && format->type != 'n' 
+        && !format->thousands_separators) 
+    { 
+        /* Fast path */ 
+        result = _PyUnicodeWriter_WriteASCIIString(writer, buf, n_digits); 
+        PyMem_Free(buf); 
+        return result; 
+    } 
+ 
+    /* Since there is no unicode version of PyOS_double_to_string, 
+       just use the 8 bit version and then convert to unicode. */ 
+    unicode_tmp = _PyUnicode_FromASCII(buf, n_digits); 
+    PyMem_Free(buf); 
+    if (unicode_tmp == NULL) 
+        goto done; 
+ 
+    /* Is a sign character present in the output?  If so, remember it 
+       and skip it */ 
+    index = 0; 
+    if (PyUnicode_READ_CHAR(unicode_tmp, index) == '-') { 
+        sign_char = '-'; 
+        ++index; 
+        --n_digits; 
+    } 
+ 
+    /* Determine if we have any "remainder" (after the digits, might include 
+       decimal or exponent or both (or neither)) */ 
+    parse_number(unicode_tmp, index, index + n_digits, &n_remainder, &has_decimal); 
+ 
+    /* Determine the grouping, separator, and decimal point, if any. */ 
+    if (get_locale_info(format->type == 'n' ? LT_CURRENT_LOCALE : 
+                        format->thousands_separators, 
+                        &locale) == -1) 
+        goto done; 
+ 
+    /* Calculate how much memory we'll need. */ 
     n_total = calc_number_widths(&spec, 0, sign_char, index,
-                                 index + n_digits, n_remainder, has_decimal,
-                                 &locale, format, &maxchar);
-    if (n_total == -1) {
-        goto done;
-    }
-
-    /* Allocate the memory. */
-    if (_PyUnicodeWriter_Prepare(writer, n_total, maxchar) == -1)
-        goto done;
-
-    /* Populate the memory. */
-    result = fill_number(writer, &spec,
+                                 index + n_digits, n_remainder, has_decimal, 
+                                 &locale, format, &maxchar); 
+    if (n_total == -1) { 
+        goto done; 
+    } 
+ 
+    /* Allocate the memory. */ 
+    if (_PyUnicodeWriter_Prepare(writer, n_total, maxchar) == -1) 
+        goto done; 
+ 
+    /* Populate the memory. */ 
+    result = fill_number(writer, &spec, 
                          unicode_tmp, index,
-                         NULL, 0, format->fill_char,
-                         &locale, 0);
-
-done:
-    Py_XDECREF(unicode_tmp);
-    free_locale_info(&locale);
-    return result;
-}
-
-/************************************************************************/
-/*********** complex formatting *****************************************/
-/************************************************************************/
-
-static int
-format_complex_internal(PyObject *value,
-                        const InternalFormatSpec *format,
-                        _PyUnicodeWriter *writer)
-{
-    double re;
-    double im;
-    char *re_buf = NULL;       /* buffer returned from PyOS_double_to_string */
-    char *im_buf = NULL;       /* buffer returned from PyOS_double_to_string */
-
-    InternalFormatSpec tmp_format = *format;
-    Py_ssize_t n_re_digits;
-    Py_ssize_t n_im_digits;
-    Py_ssize_t n_re_remainder;
-    Py_ssize_t n_im_remainder;
-    Py_ssize_t n_re_total;
-    Py_ssize_t n_im_total;
-    int re_has_decimal;
-    int im_has_decimal;
-    int precision, default_precision = 6;
-    Py_UCS4 type = format->type;
-    Py_ssize_t i_re;
-    Py_ssize_t i_im;
-    NumberFieldWidths re_spec;
-    NumberFieldWidths im_spec;
-    int flags = 0;
-    int result = -1;
-    Py_UCS4 maxchar = 127;
-    enum PyUnicode_Kind rkind;
-    void *rdata;
-    Py_UCS4 re_sign_char = '\0';
-    Py_UCS4 im_sign_char = '\0';
-    int re_float_type; /* Used to see if we have a nan, inf, or regular float. */
-    int im_float_type;
-    int add_parens = 0;
-    int skip_re = 0;
-    Py_ssize_t lpad;
-    Py_ssize_t rpad;
-    Py_ssize_t total;
-    PyObject *re_unicode_tmp = NULL;
-    PyObject *im_unicode_tmp = NULL;
-
-    /* Locale settings, either from the actual locale or
-       from a hard-code pseudo-locale */
+                         NULL, 0, format->fill_char, 
+                         &locale, 0); 
+ 
+done: 
+    Py_XDECREF(unicode_tmp); 
+    free_locale_info(&locale); 
+    return result; 
+} 
+ 
+/************************************************************************/ 
+/*********** complex formatting *****************************************/ 
+/************************************************************************/ 
+ 
+static int 
+format_complex_internal(PyObject *value, 
+                        const InternalFormatSpec *format, 
+                        _PyUnicodeWriter *writer) 
+{ 
+    double re; 
+    double im; 
+    char *re_buf = NULL;       /* buffer returned from PyOS_double_to_string */ 
+    char *im_buf = NULL;       /* buffer returned from PyOS_double_to_string */ 
+ 
+    InternalFormatSpec tmp_format = *format; 
+    Py_ssize_t n_re_digits; 
+    Py_ssize_t n_im_digits; 
+    Py_ssize_t n_re_remainder; 
+    Py_ssize_t n_im_remainder; 
+    Py_ssize_t n_re_total; 
+    Py_ssize_t n_im_total; 
+    int re_has_decimal; 
+    int im_has_decimal; 
+    int precision, default_precision = 6; 
+    Py_UCS4 type = format->type; 
+    Py_ssize_t i_re; 
+    Py_ssize_t i_im; 
+    NumberFieldWidths re_spec; 
+    NumberFieldWidths im_spec; 
+    int flags = 0; 
+    int result = -1; 
+    Py_UCS4 maxchar = 127; 
+    enum PyUnicode_Kind rkind; 
+    void *rdata; 
+    Py_UCS4 re_sign_char = '\0'; 
+    Py_UCS4 im_sign_char = '\0'; 
+    int re_float_type; /* Used to see if we have a nan, inf, or regular float. */ 
+    int im_float_type; 
+    int add_parens = 0; 
+    int skip_re = 0; 
+    Py_ssize_t lpad; 
+    Py_ssize_t rpad; 
+    Py_ssize_t total; 
+    PyObject *re_unicode_tmp = NULL; 
+    PyObject *im_unicode_tmp = NULL; 
+ 
+    /* Locale settings, either from the actual locale or 
+       from a hard-code pseudo-locale */ 
     LocaleInfo locale = LocaleInfo_STATIC_INIT;
-
-    if (format->precision > INT_MAX) {
-        PyErr_SetString(PyExc_ValueError, "precision too big");
-        goto done;
-    }
-    precision = (int)format->precision;
-
-    /* Zero padding is not allowed. */
-    if (format->fill_char == '0') {
-        PyErr_SetString(PyExc_ValueError,
-                        "Zero padding is not allowed in complex format "
-                        "specifier");
-        goto done;
-    }
-
-    /* Neither is '=' alignment . */
-    if (format->align == '=') {
-        PyErr_SetString(PyExc_ValueError,
-                        "'=' alignment flag is not allowed in complex format "
-                        "specifier");
-        goto done;
-    }
-
-    re = PyComplex_RealAsDouble(value);
-    if (re == -1.0 && PyErr_Occurred())
-        goto done;
-    im = PyComplex_ImagAsDouble(value);
-    if (im == -1.0 && PyErr_Occurred())
-        goto done;
-
-    if (format->alternate)
-        flags |= Py_DTSF_ALT;
-
-    if (type == '\0') {
-        /* Omitted type specifier. Should be like str(self). */
-        type = 'r';
-        default_precision = 0;
-        if (re == 0.0 && copysign(1.0, re) == 1.0)
-            skip_re = 1;
-        else
-            add_parens = 1;
-    }
-
-    if (type == 'n')
-        /* 'n' is the same as 'g', except for the locale used to
-           format the result. We take care of that later. */
-        type = 'g';
-
-    if (precision < 0)
-        precision = default_precision;
-    else if (type == 'r')
-        type = 'g';
-
-    /* Cast "type", because if we're in unicode we need to pass an
-       8-bit char. This is safe, because we've restricted what "type"
-       can be. */
-    re_buf = PyOS_double_to_string(re, (char)type, precision, flags,
-                                   &re_float_type);
-    if (re_buf == NULL)
-        goto done;
-    im_buf = PyOS_double_to_string(im, (char)type, precision, flags,
-                                   &im_float_type);
-    if (im_buf == NULL)
-        goto done;
-
-    n_re_digits = strlen(re_buf);
-    n_im_digits = strlen(im_buf);
-
-    /* Since there is no unicode version of PyOS_double_to_string,
-       just use the 8 bit version and then convert to unicode. */
-    re_unicode_tmp = _PyUnicode_FromASCII(re_buf, n_re_digits);
-    if (re_unicode_tmp == NULL)
-        goto done;
-    i_re = 0;
-
-    im_unicode_tmp = _PyUnicode_FromASCII(im_buf, n_im_digits);
-    if (im_unicode_tmp == NULL)
-        goto done;
-    i_im = 0;
-
-    /* Is a sign character present in the output?  If so, remember it
-       and skip it */
-    if (PyUnicode_READ_CHAR(re_unicode_tmp, i_re) == '-') {
-        re_sign_char = '-';
-        ++i_re;
-        --n_re_digits;
-    }
-    if (PyUnicode_READ_CHAR(im_unicode_tmp, i_im) == '-') {
-        im_sign_char = '-';
-        ++i_im;
-        --n_im_digits;
-    }
-
-    /* Determine if we have any "remainder" (after the digits, might include
-       decimal or exponent or both (or neither)) */
-    parse_number(re_unicode_tmp, i_re, i_re + n_re_digits,
-                 &n_re_remainder, &re_has_decimal);
-    parse_number(im_unicode_tmp, i_im, i_im + n_im_digits,
-                 &n_im_remainder, &im_has_decimal);
-
-    /* Determine the grouping, separator, and decimal point, if any. */
-    if (get_locale_info(format->type == 'n' ? LT_CURRENT_LOCALE :
-                        format->thousands_separators,
-                        &locale) == -1)
-        goto done;
-
-    /* Turn off any padding. We'll do it later after we've composed
-       the numbers without padding. */
-    tmp_format.fill_char = '\0';
-    tmp_format.align = '<';
-    tmp_format.width = -1;
-
-    /* Calculate how much memory we'll need. */
+ 
+    if (format->precision > INT_MAX) { 
+        PyErr_SetString(PyExc_ValueError, "precision too big"); 
+        goto done; 
+    } 
+    precision = (int)format->precision; 
+ 
+    /* Zero padding is not allowed. */ 
+    if (format->fill_char == '0') { 
+        PyErr_SetString(PyExc_ValueError, 
+                        "Zero padding is not allowed in complex format " 
+                        "specifier"); 
+        goto done; 
+    } 
+ 
+    /* Neither is '=' alignment . */ 
+    if (format->align == '=') { 
+        PyErr_SetString(PyExc_ValueError, 
+                        "'=' alignment flag is not allowed in complex format " 
+                        "specifier"); 
+        goto done; 
+    } 
+ 
+    re = PyComplex_RealAsDouble(value); 
+    if (re == -1.0 && PyErr_Occurred()) 
+        goto done; 
+    im = PyComplex_ImagAsDouble(value); 
+    if (im == -1.0 && PyErr_Occurred()) 
+        goto done; 
+ 
+    if (format->alternate) 
+        flags |= Py_DTSF_ALT; 
+ 
+    if (type == '\0') { 
+        /* Omitted type specifier. Should be like str(self). */ 
+        type = 'r'; 
+        default_precision = 0; 
+        if (re == 0.0 && copysign(1.0, re) == 1.0) 
+            skip_re = 1; 
+        else 
+            add_parens = 1; 
+    } 
+ 
+    if (type == 'n') 
+        /* 'n' is the same as 'g', except for the locale used to 
+           format the result. We take care of that later. */ 
+        type = 'g'; 
+ 
+    if (precision < 0) 
+        precision = default_precision; 
+    else if (type == 'r') 
+        type = 'g'; 
+ 
+    /* Cast "type", because if we're in unicode we need to pass an 
+       8-bit char. This is safe, because we've restricted what "type" 
+       can be. */ 
+    re_buf = PyOS_double_to_string(re, (char)type, precision, flags, 
+                                   &re_float_type); 
+    if (re_buf == NULL) 
+        goto done; 
+    im_buf = PyOS_double_to_string(im, (char)type, precision, flags, 
+                                   &im_float_type); 
+    if (im_buf == NULL) 
+        goto done; 
+ 
+    n_re_digits = strlen(re_buf); 
+    n_im_digits = strlen(im_buf); 
+ 
+    /* Since there is no unicode version of PyOS_double_to_string, 
+       just use the 8 bit version and then convert to unicode. */ 
+    re_unicode_tmp = _PyUnicode_FromASCII(re_buf, n_re_digits); 
+    if (re_unicode_tmp == NULL) 
+        goto done; 
+    i_re = 0; 
+ 
+    im_unicode_tmp = _PyUnicode_FromASCII(im_buf, n_im_digits); 
+    if (im_unicode_tmp == NULL) 
+        goto done; 
+    i_im = 0; 
+ 
+    /* Is a sign character present in the output?  If so, remember it 
+       and skip it */ 
+    if (PyUnicode_READ_CHAR(re_unicode_tmp, i_re) == '-') { 
+        re_sign_char = '-'; 
+        ++i_re; 
+        --n_re_digits; 
+    } 
+    if (PyUnicode_READ_CHAR(im_unicode_tmp, i_im) == '-') { 
+        im_sign_char = '-'; 
+        ++i_im; 
+        --n_im_digits; 
+    } 
+ 
+    /* Determine if we have any "remainder" (after the digits, might include 
+       decimal or exponent or both (or neither)) */ 
+    parse_number(re_unicode_tmp, i_re, i_re + n_re_digits, 
+                 &n_re_remainder, &re_has_decimal); 
+    parse_number(im_unicode_tmp, i_im, i_im + n_im_digits, 
+                 &n_im_remainder, &im_has_decimal); 
+ 
+    /* Determine the grouping, separator, and decimal point, if any. */ 
+    if (get_locale_info(format->type == 'n' ? LT_CURRENT_LOCALE : 
+                        format->thousands_separators, 
+                        &locale) == -1) 
+        goto done; 
+ 
+    /* Turn off any padding. We'll do it later after we've composed 
+       the numbers without padding. */ 
+    tmp_format.fill_char = '\0'; 
+    tmp_format.align = '<'; 
+    tmp_format.width = -1; 
+ 
+    /* Calculate how much memory we'll need. */ 
     n_re_total = calc_number_widths(&re_spec, 0, re_sign_char,
-                                    i_re, i_re + n_re_digits, n_re_remainder,
-                                    re_has_decimal, &locale, &tmp_format,
-                                    &maxchar);
-    if (n_re_total == -1) {
-        goto done;
-    }
-
-    /* Same formatting, but always include a sign, unless the real part is
-     * going to be omitted, in which case we use whatever sign convention was
-     * requested by the original format. */
-    if (!skip_re)
-        tmp_format.sign = '+';
+                                    i_re, i_re + n_re_digits, n_re_remainder, 
+                                    re_has_decimal, &locale, &tmp_format, 
+                                    &maxchar); 
+    if (n_re_total == -1) { 
+        goto done; 
+    } 
+ 
+    /* Same formatting, but always include a sign, unless the real part is 
+     * going to be omitted, in which case we use whatever sign convention was 
+     * requested by the original format. */ 
+    if (!skip_re) 
+        tmp_format.sign = '+'; 
     n_im_total = calc_number_widths(&im_spec, 0, im_sign_char,
-                                    i_im, i_im + n_im_digits, n_im_remainder,
-                                    im_has_decimal, &locale, &tmp_format,
-                                    &maxchar);
-    if (n_im_total == -1) {
-        goto done;
-    }
-
-    if (skip_re)
-        n_re_total = 0;
-
-    /* Add 1 for the 'j', and optionally 2 for parens. */
-    calc_padding(n_re_total + n_im_total + 1 + add_parens * 2,
-                 format->width, format->align, &lpad, &rpad, &total);
-
-    if (lpad || rpad)
-        maxchar = Py_MAX(maxchar, format->fill_char);
-
-    if (_PyUnicodeWriter_Prepare(writer, total, maxchar) == -1)
-        goto done;
-    rkind = writer->kind;
-    rdata = writer->data;
-
-    /* Populate the memory. First, the padding. */
-    result = fill_padding(writer,
-                          n_re_total + n_im_total + 1 + add_parens * 2,
-                          format->fill_char, lpad, rpad);
-    if (result == -1)
-        goto done;
-
-    if (add_parens) {
-        PyUnicode_WRITE(rkind, rdata, writer->pos, '(');
-        writer->pos++;
-    }
-
-    if (!skip_re) {
-        result = fill_number(writer, &re_spec,
+                                    i_im, i_im + n_im_digits, n_im_remainder, 
+                                    im_has_decimal, &locale, &tmp_format, 
+                                    &maxchar); 
+    if (n_im_total == -1) { 
+        goto done; 
+    } 
+ 
+    if (skip_re) 
+        n_re_total = 0; 
+ 
+    /* Add 1 for the 'j', and optionally 2 for parens. */ 
+    calc_padding(n_re_total + n_im_total + 1 + add_parens * 2, 
+                 format->width, format->align, &lpad, &rpad, &total); 
+ 
+    if (lpad || rpad) 
+        maxchar = Py_MAX(maxchar, format->fill_char); 
+ 
+    if (_PyUnicodeWriter_Prepare(writer, total, maxchar) == -1) 
+        goto done; 
+    rkind = writer->kind; 
+    rdata = writer->data; 
+ 
+    /* Populate the memory. First, the padding. */ 
+    result = fill_padding(writer, 
+                          n_re_total + n_im_total + 1 + add_parens * 2, 
+                          format->fill_char, lpad, rpad); 
+    if (result == -1) 
+        goto done; 
+ 
+    if (add_parens) { 
+        PyUnicode_WRITE(rkind, rdata, writer->pos, '('); 
+        writer->pos++; 
+    } 
+ 
+    if (!skip_re) { 
+        result = fill_number(writer, &re_spec, 
                              re_unicode_tmp, i_re,
-                             NULL, 0,
-                             0,
-                             &locale, 0);
-        if (result == -1)
-            goto done;
-    }
-    result = fill_number(writer, &im_spec,
+                             NULL, 0, 
+                             0, 
+                             &locale, 0); 
+        if (result == -1) 
+            goto done; 
+    } 
+    result = fill_number(writer, &im_spec, 
                          im_unicode_tmp, i_im,
-                         NULL, 0,
-                         0,
-                         &locale, 0);
-    if (result == -1)
-        goto done;
-    PyUnicode_WRITE(rkind, rdata, writer->pos, 'j');
-    writer->pos++;
-
-    if (add_parens) {
-        PyUnicode_WRITE(rkind, rdata, writer->pos, ')');
-        writer->pos++;
-    }
-
-    writer->pos += rpad;
-
-done:
-    PyMem_Free(re_buf);
-    PyMem_Free(im_buf);
-    Py_XDECREF(re_unicode_tmp);
-    Py_XDECREF(im_unicode_tmp);
-    free_locale_info(&locale);
-    return result;
-}
-
-/************************************************************************/
-/*********** built in formatters ****************************************/
-/************************************************************************/
-static int
-format_obj(PyObject *obj, _PyUnicodeWriter *writer)
-{
-    PyObject *str;
-    int err;
-
-    str = PyObject_Str(obj);
-    if (str == NULL)
-        return -1;
-    err = _PyUnicodeWriter_WriteStr(writer, str);
-    Py_DECREF(str);
-    return err;
-}
-
-int
-_PyUnicode_FormatAdvancedWriter(_PyUnicodeWriter *writer,
-                                PyObject *obj,
-                                PyObject *format_spec,
-                                Py_ssize_t start, Py_ssize_t end)
-{
-    InternalFormatSpec format;
-
-    assert(PyUnicode_Check(obj));
-
-    /* check for the special case of zero length format spec, make
-       it equivalent to str(obj) */
-    if (start == end) {
-        if (PyUnicode_CheckExact(obj))
-            return _PyUnicodeWriter_WriteStr(writer, obj);
-        else
-            return format_obj(obj, writer);
-    }
-
-    /* parse the format_spec */
-    if (!parse_internal_render_format_spec(format_spec, start, end,
-                                           &format, 's', '<'))
-        return -1;
-
-    /* type conversion? */
-    switch (format.type) {
-    case 's':
-        /* no type conversion needed, already a string.  do the formatting */
-        return format_string_internal(obj, &format, writer);
-    default:
-        /* unknown */
+                         NULL, 0, 
+                         0, 
+                         &locale, 0); 
+    if (result == -1) 
+        goto done; 
+    PyUnicode_WRITE(rkind, rdata, writer->pos, 'j'); 
+    writer->pos++; 
+ 
+    if (add_parens) { 
+        PyUnicode_WRITE(rkind, rdata, writer->pos, ')'); 
+        writer->pos++; 
+    } 
+ 
+    writer->pos += rpad; 
+ 
+done: 
+    PyMem_Free(re_buf); 
+    PyMem_Free(im_buf); 
+    Py_XDECREF(re_unicode_tmp); 
+    Py_XDECREF(im_unicode_tmp); 
+    free_locale_info(&locale); 
+    return result; 
+} 
+ 
+/************************************************************************/ 
+/*********** built in formatters ****************************************/ 
+/************************************************************************/ 
+static int 
+format_obj(PyObject *obj, _PyUnicodeWriter *writer) 
+{ 
+    PyObject *str; 
+    int err; 
+ 
+    str = PyObject_Str(obj); 
+    if (str == NULL) 
+        return -1; 
+    err = _PyUnicodeWriter_WriteStr(writer, str); 
+    Py_DECREF(str); 
+    return err; 
+} 
+ 
+int 
+_PyUnicode_FormatAdvancedWriter(_PyUnicodeWriter *writer, 
+                                PyObject *obj, 
+                                PyObject *format_spec, 
+                                Py_ssize_t start, Py_ssize_t end) 
+{ 
+    InternalFormatSpec format; 
+ 
+    assert(PyUnicode_Check(obj)); 
+ 
+    /* check for the special case of zero length format spec, make 
+       it equivalent to str(obj) */ 
+    if (start == end) { 
+        if (PyUnicode_CheckExact(obj)) 
+            return _PyUnicodeWriter_WriteStr(writer, obj); 
+        else 
+            return format_obj(obj, writer); 
+    } 
+ 
+    /* parse the format_spec */ 
+    if (!parse_internal_render_format_spec(format_spec, start, end, 
+                                           &format, 's', '<')) 
+        return -1; 
+ 
+    /* type conversion? */ 
+    switch (format.type) { 
+    case 's': 
+        /* no type conversion needed, already a string.  do the formatting */ 
+        return format_string_internal(obj, &format, writer); 
+    default: 
+        /* unknown */ 
         unknown_presentation_type(format.type, Py_TYPE(obj)->tp_name);
-        return -1;
-    }
-}
-
-int
-_PyLong_FormatAdvancedWriter(_PyUnicodeWriter *writer,
-                             PyObject *obj,
-                             PyObject *format_spec,
-                             Py_ssize_t start, Py_ssize_t end)
-{
+        return -1; 
+    } 
+} 
+ 
+int 
+_PyLong_FormatAdvancedWriter(_PyUnicodeWriter *writer, 
+                             PyObject *obj, 
+                             PyObject *format_spec, 
+                             Py_ssize_t start, Py_ssize_t end) 
+{ 
     PyObject *tmp = NULL;
-    InternalFormatSpec format;
-    int result = -1;
-
-    /* check for the special case of zero length format spec, make
-       it equivalent to str(obj) */
-    if (start == end) {
-        if (PyLong_CheckExact(obj))
-            return _PyLong_FormatWriter(writer, obj, 10, 0);
-        else
-            return format_obj(obj, writer);
-    }
-
-    /* parse the format_spec */
-    if (!parse_internal_render_format_spec(format_spec, start, end,
-                                           &format, 'd', '>'))
-        goto done;
-
-    /* type conversion? */
-    switch (format.type) {
-    case 'b':
-    case 'c':
-    case 'd':
-    case 'o':
-    case 'x':
-    case 'X':
-    case 'n':
-        /* no type conversion needed, already an int.  do the formatting */
-        result = format_long_internal(obj, &format, writer);
-        break;
-
-    case 'e':
-    case 'E':
-    case 'f':
-    case 'F':
-    case 'g':
-    case 'G':
-    case '%':
-        /* convert to float */
-        tmp = PyNumber_Float(obj);
-        if (tmp == NULL)
-            goto done;
-        result = format_float_internal(tmp, &format, writer);
-        break;
-
-    default:
-        /* unknown */
+    InternalFormatSpec format; 
+    int result = -1; 
+ 
+    /* check for the special case of zero length format spec, make 
+       it equivalent to str(obj) */ 
+    if (start == end) { 
+        if (PyLong_CheckExact(obj)) 
+            return _PyLong_FormatWriter(writer, obj, 10, 0); 
+        else 
+            return format_obj(obj, writer); 
+    } 
+ 
+    /* parse the format_spec */ 
+    if (!parse_internal_render_format_spec(format_spec, start, end, 
+                                           &format, 'd', '>')) 
+        goto done; 
+ 
+    /* type conversion? */ 
+    switch (format.type) { 
+    case 'b': 
+    case 'c': 
+    case 'd': 
+    case 'o': 
+    case 'x': 
+    case 'X': 
+    case 'n': 
+        /* no type conversion needed, already an int.  do the formatting */ 
+        result = format_long_internal(obj, &format, writer); 
+        break; 
+ 
+    case 'e': 
+    case 'E': 
+    case 'f': 
+    case 'F': 
+    case 'g': 
+    case 'G': 
+    case '%': 
+        /* convert to float */ 
+        tmp = PyNumber_Float(obj); 
+        if (tmp == NULL) 
+            goto done; 
+        result = format_float_internal(tmp, &format, writer); 
+        break; 
+ 
+    default: 
+        /* unknown */ 
         unknown_presentation_type(format.type, Py_TYPE(obj)->tp_name);
-        goto done;
-    }
-
-done:
-    Py_XDECREF(tmp);
-    return result;
-}
-
-int
-_PyFloat_FormatAdvancedWriter(_PyUnicodeWriter *writer,
-                              PyObject *obj,
-                              PyObject *format_spec,
-                              Py_ssize_t start, Py_ssize_t end)
-{
-    InternalFormatSpec format;
-
-    /* check for the special case of zero length format spec, make
-       it equivalent to str(obj) */
-    if (start == end)
-        return format_obj(obj, writer);
-
-    /* parse the format_spec */
-    if (!parse_internal_render_format_spec(format_spec, start, end,
-                                           &format, '\0', '>'))
-        return -1;
-
-    /* type conversion? */
-    switch (format.type) {
-    case '\0': /* No format code: like 'g', but with at least one decimal. */
-    case 'e':
-    case 'E':
-    case 'f':
-    case 'F':
-    case 'g':
-    case 'G':
-    case 'n':
-    case '%':
-        /* no conversion, already a float.  do the formatting */
-        return format_float_internal(obj, &format, writer);
-
-    default:
-        /* unknown */
+        goto done; 
+    } 
+ 
+done: 
+    Py_XDECREF(tmp); 
+    return result; 
+} 
+ 
+int 
+_PyFloat_FormatAdvancedWriter(_PyUnicodeWriter *writer, 
+                              PyObject *obj, 
+                              PyObject *format_spec, 
+                              Py_ssize_t start, Py_ssize_t end) 
+{ 
+    InternalFormatSpec format; 
+ 
+    /* check for the special case of zero length format spec, make 
+       it equivalent to str(obj) */ 
+    if (start == end) 
+        return format_obj(obj, writer); 
+ 
+    /* parse the format_spec */ 
+    if (!parse_internal_render_format_spec(format_spec, start, end, 
+                                           &format, '\0', '>')) 
+        return -1; 
+ 
+    /* type conversion? */ 
+    switch (format.type) { 
+    case '\0': /* No format code: like 'g', but with at least one decimal. */ 
+    case 'e': 
+    case 'E': 
+    case 'f': 
+    case 'F': 
+    case 'g': 
+    case 'G': 
+    case 'n': 
+    case '%': 
+        /* no conversion, already a float.  do the formatting */ 
+        return format_float_internal(obj, &format, writer); 
+ 
+    default: 
+        /* unknown */ 
         unknown_presentation_type(format.type, Py_TYPE(obj)->tp_name);
-        return -1;
-    }
-}
-
-int
-_PyComplex_FormatAdvancedWriter(_PyUnicodeWriter *writer,
-                                PyObject *obj,
-                                PyObject *format_spec,
-                                Py_ssize_t start, Py_ssize_t end)
-{
-    InternalFormatSpec format;
-
-    /* check for the special case of zero length format spec, make
-       it equivalent to str(obj) */
-    if (start == end)
-        return format_obj(obj, writer);
-
-    /* parse the format_spec */
-    if (!parse_internal_render_format_spec(format_spec, start, end,
-                                           &format, '\0', '>'))
-        return -1;
-
-    /* type conversion? */
-    switch (format.type) {
-    case '\0': /* No format code: like 'g', but with at least one decimal. */
-    case 'e':
-    case 'E':
-    case 'f':
-    case 'F':
-    case 'g':
-    case 'G':
-    case 'n':
-        /* no conversion, already a complex.  do the formatting */
-        return format_complex_internal(obj, &format, writer);
-
-    default:
-        /* unknown */
+        return -1; 
+    } 
+} 
+ 
+int 
+_PyComplex_FormatAdvancedWriter(_PyUnicodeWriter *writer, 
+                                PyObject *obj, 
+                                PyObject *format_spec, 
+                                Py_ssize_t start, Py_ssize_t end) 
+{ 
+    InternalFormatSpec format; 
+ 
+    /* check for the special case of zero length format spec, make 
+       it equivalent to str(obj) */ 
+    if (start == end) 
+        return format_obj(obj, writer); 
+ 
+    /* parse the format_spec */ 
+    if (!parse_internal_render_format_spec(format_spec, start, end, 
+                                           &format, '\0', '>')) 
+        return -1; 
+ 
+    /* type conversion? */ 
+    switch (format.type) { 
+    case '\0': /* No format code: like 'g', but with at least one decimal. */ 
+    case 'e': 
+    case 'E': 
+    case 'f': 
+    case 'F': 
+    case 'g': 
+    case 'G': 
+    case 'n': 
+        /* no conversion, already a complex.  do the formatting */ 
+        return format_complex_internal(obj, &format, writer); 
+ 
+    default: 
+        /* unknown */ 
         unknown_presentation_type(format.type, Py_TYPE(obj)->tp_name);
-        return -1;
-    }
-}
+        return -1; 
+    } 
+}