unicode_format.h

/*
 unicode_format.h -- implementation of str.format().
*/

#include"pycore_complexobject.h"// _PyComplex_FormatAdvancedWriter()
#include"pycore_floatobject.h"// _PyFloat_FormatAdvancedWriter()

/************************************************************************/
/*********** Global data structures and forward declarations *********/
/************************************************************************/

/*
 A SubString consists of the characters between two string or
 unicode pointers.
*/
typedefstruct {
PyObject*str; /* borrowed reference */
Py_ssize_tstart, end;
} SubString;


typedefenum {
ANS_INIT,
ANS_AUTO,
ANS_MANUAL
} AutoNumberState; /* Keep track if we're auto-numbering fields */

/* Keeps track of our auto-numbering state, and which number field we're on */
typedefstruct {
AutoNumberStatean_state;
intan_field_number;
} AutoNumber;


/* forward declaration for recursion */
staticPyObject*
build_string(SubString*input, PyObject*args, PyObject*kwargs,
intrecursion_depth, AutoNumber*auto_number);



/************************************************************************/
/************************** Utility functions ************************/
/************************************************************************/

staticvoid
AutoNumber_Init(AutoNumber*auto_number)
{
auto_number->an_state=ANS_INIT;
auto_number->an_field_number=0;
}

/* fill in a SubString from a pointer and length */
Py_LOCAL_INLINE(void)
SubString_init(SubString*str, PyObject*s, Py_ssize_tstart, Py_ssize_tend)
{
str->str=s;
str->start=start;
str->end=end;
}

/* return a new string. if str->str is NULL, return None */
Py_LOCAL_INLINE(PyObject*)
SubString_new_object(SubString*str)
{
if (str->str==NULL)
Py_RETURN_NONE;
returnPyUnicode_Substring(str->str, str->start, str->end);
}

/* return a new string. if str->str is NULL, return a new empty string */
Py_LOCAL_INLINE(PyObject*)
SubString_new_object_or_empty(SubString*str)
{
if (str->str==NULL) {
returnPyUnicode_New(0, 0);
 }
returnSubString_new_object(str);
}

/* Return 1 if an error has been detected switching between automatic
 field numbering and manual field specification, else return 0. Set
 ValueError on error. */
staticint
autonumber_state_error(AutoNumberStatestate, intfield_name_is_empty)
{
if (state==ANS_MANUAL) {
if (field_name_is_empty) {
PyErr_SetString(PyExc_ValueError, "cannot switch from "
"manual field specification to "
"automatic field numbering");
return1;
 }
 }
else {
if (!field_name_is_empty) {
PyErr_SetString(PyExc_ValueError, "cannot switch from "
"automatic field numbering to "
"manual field specification");
return1;
 }
 }
return0;
}


/************************************************************************/
/*********** Format string parsing -- integers and identifiers *********/
/************************************************************************/

staticPy_ssize_t
get_integer(constSubString*str)
{
Py_ssize_taccumulator=0;
Py_ssize_tdigitval;
Py_ssize_ti;

/* empty string is an error */
if (str->start >= str->end)
return-1;

for (i=str->start; i<str->end; i++) {
digitval=Py_UNICODE_TODECIMAL(PyUnicode_READ_CHAR(str->str, i));
if (digitval<0)
return-1;
/*
 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");
return-1;
 }
accumulator=accumulator*10+digitval;
 }
returnaccumulator;
}

/************************************************************************/
/******** Functions to get field objects and specification strings ******/
/************************************************************************/

/* do the equivalent of obj.name */
staticPyObject*
getattr(PyObject*obj, SubString*name)
{
PyObject*newobj;
PyObject*str=SubString_new_object(name);
if (str==NULL)
returnNULL;
newobj=PyObject_GetAttr(obj, str);
Py_DECREF(str);
returnnewobj;
}

/* do the equivalent of obj[idx], where obj is a sequence */
staticPyObject*
getitem_sequence(PyObject*obj, Py_ssize_tidx)
{
returnPySequence_GetItem(obj, idx);
}

/* do the equivalent of obj[idx], where obj is not a sequence */
staticPyObject*
getitem_idx(PyObject*obj, Py_ssize_tidx)
{
PyObject*newobj;
PyObject*idx_obj=PyLong_FromSsize_t(idx);
if (idx_obj==NULL)
returnNULL;
newobj=PyObject_GetItem(obj, idx_obj);
Py_DECREF(idx_obj);
returnnewobj;
}

/* do the equivalent of obj[name] */
staticPyObject*
getitem_str(PyObject*obj, SubString*name)
{
PyObject*newobj;
PyObject*str=SubString_new_object(name);
if (str==NULL)
returnNULL;
newobj=PyObject_GetItem(obj, str);
Py_DECREF(str);
returnnewobj;
}

typedefstruct {
/* the entire string we're parsing. we assume that someone else
 is managing its lifetime, and that it will exist for the
 lifetime of the iterator. can be empty */
SubStringstr;

/* index to where we are inside field_name */
Py_ssize_tindex;
} FieldNameIterator;


staticint
FieldNameIterator_init(FieldNameIterator*self, PyObject*s,
Py_ssize_tstart, Py_ssize_tend)
{
SubString_init(&self->str, s, start, end);
self->index=start;
return1;
}

staticint
_FieldNameIterator_attr(FieldNameIterator*self, SubString*name)
{
Py_UCS4c;

name->str=self->str.str;
name->start=self->index;

/* return everything until '.' or '[' */
while (self->index<self->str.end) {
c=PyUnicode_READ_CHAR(self->str.str, self->index++);
switch (c) {
case'[':
case'.':
/* backup so that we this character will be seen next time */
self->index--;
break;
default:
continue;
 }
break;
 }
/* end of string is okay */
name->end=self->index;
return1;
}

staticint
_FieldNameIterator_item(FieldNameIterator*self, SubString*name)
{
intbracket_seen=0;
Py_UCS4c;

name->str=self->str.str;
name->start=self->index;

/* return everything until ']' */
while (self->index<self->str.end) {
c=PyUnicode_READ_CHAR(self->str.str, self->index++);
switch (c) {
case']':
bracket_seen=1;
break;
default:
continue;
 }
break;
 }
/* make sure we ended with a ']' */
if (!bracket_seen) {
PyErr_SetString(PyExc_ValueError, "Missing ']' in format string");
return0;
 }

/* end of string is okay */
/* don't include the ']' */
name->end=self->index-1;
return1;
}

/* returns 0 on error, 1 on non-error termination, and 2 if it returns a value */
staticint
FieldNameIterator_next(FieldNameIterator*self, int*is_attribute,
Py_ssize_t*name_idx, SubString*name)
{
/* check at end of input */
if (self->index >= self->str.end)
return1;

switch (PyUnicode_READ_CHAR(self->str.str, self->index++)) {
case'.':
*is_attribute=1;
if (_FieldNameIterator_attr(self, name) ==0)
return0;
*name_idx=-1;
break;
case'[':
*is_attribute=0;
if (_FieldNameIterator_item(self, name) ==0)
return0;
*name_idx=get_integer(name);
if (*name_idx==-1&&PyErr_Occurred())
return0;
break;
default:
/* Invalid character follows ']' */
PyErr_SetString(PyExc_ValueError, "Only '.' or '[' may "
"follow ']' in format field specifier");
return0;
 }

/* empty string is an error */
if (name->start==name->end) {
PyErr_SetString(PyExc_ValueError, "Empty attribute in format string");
return0;
 }

return2;
}


/* input: field_name
 output: 'first' points to the part before the first '[' or '.'
 'first_idx' is -1 if 'first' is not an integer, otherwise
 it's the value of first converted to an integer
 'rest' is an iterator to return the rest
*/
staticint
field_name_split(PyObject*str, Py_ssize_tstart, Py_ssize_tend, SubString*first,
Py_ssize_t*first_idx, FieldNameIterator*rest,
AutoNumber*auto_number)
{
Py_UCS4c;
Py_ssize_ti=start;
intfield_name_is_empty;
intusing_numeric_index;

/* find the part up until the first '.' or '[' */
while (i<end) {
switch (c=PyUnicode_READ_CHAR(str, i++)) {
case'[':
case'.':
/* backup so that we this character is available to the
 "rest" iterator */
i--;
break;
default:
continue;
 }
break;
 }

/* set up the return values */
SubString_init(first, str, start, i);
FieldNameIterator_init(rest, str, i, end);

/* see if "first" is an integer, in which case it's used as an index */
*first_idx=get_integer(first);
if (*first_idx==-1&&PyErr_Occurred())
return0;

field_name_is_empty=first->start >= first->end;

/* If the field name is omitted or if we have a numeric index
 specified, then we're doing numeric indexing into args. */
using_numeric_index=field_name_is_empty||*first_idx!=-1;

/* We always get here exactly one time for each field we're
 processing. And we get here in field order (counting by left
 braces). So this is the perfect place to handle automatic field
 numbering if the field name is omitted. */

/* Check if we need to do the auto-numbering. It's not needed if
 we're called from string.Format routines, because it's handled
 in that class by itself. */
if (auto_number) {
/* Initialize our auto numbering state if this is the first
 time we're either auto-numbering or manually numbering. */
if (auto_number->an_state==ANS_INIT&&using_numeric_index)
auto_number->an_state=field_name_is_empty ?
ANS_AUTO : ANS_MANUAL;

/* Make sure our state is consistent with what we're doing
 this time through. Only check if we're using a numeric
 index. */
if (using_numeric_index)
if (autonumber_state_error(auto_number->an_state,
field_name_is_empty))
return0;
/* Zero length field means we want to do auto-numbering of the
 fields. */
if (field_name_is_empty)
*first_idx= (auto_number->an_field_number)++;
 }

return1;
}


/*
 get_field_object returns the object inside {}, before the
 format_spec. It handles getindex and getattr lookups and consumes
 the entire input string.
*/
staticPyObject*
get_field_object(SubString*input, PyObject*args, PyObject*kwargs,
AutoNumber*auto_number)
{
PyObject*obj=NULL;
intok;
intis_attribute;
SubStringname;
SubStringfirst;
Py_ssize_tindex;
FieldNameIteratorrest;

if (!field_name_split(input->str, input->start, input->end, &first,
&index, &rest, auto_number)) {
 goto error;
 }

if (index==-1) {
/* look up in kwargs */
PyObject*key=SubString_new_object(&first);
if (key==NULL) {
 goto error;
 }
if (kwargs==NULL) {
PyErr_SetObject(PyExc_KeyError, key);
Py_DECREF(key);
 goto error;
 }
/* Use PyObject_GetItem instead of PyDict_GetItem because this
 code is no longer just used with kwargs. It might be passed
 a non-dict when called through format_map. */
obj=PyObject_GetItem(kwargs, key);
Py_DECREF(key);
if (obj==NULL) {
 goto error;
 }
 }
else {
/* If args is NULL, we have a format string with a positional field
 with only kwargs to retrieve it from. This can only happen when
 used with format_map(), where positional arguments are not
 allowed. */
if (args==NULL) {
PyErr_SetString(PyExc_ValueError, "Format string contains "
"positional fields");
 goto error;
 }

/* look up in args */
obj=PySequence_GetItem(args, index);
if (obj==NULL) {
PyErr_Format(PyExc_IndexError,
"Replacement index %zd out of range for positional "
"args tuple",
index);
 goto error;
 }
 }

/* iterate over the rest of the field_name */
while ((ok=FieldNameIterator_next(&rest, &is_attribute, &index,
&name)) ==2) {
PyObject*tmp;

if (is_attribute)
/* getattr lookup "." */
tmp=getattr(obj, &name);
else
/* getitem lookup "[]" */
if (index==-1)
tmp=getitem_str(obj, &name);
else
if (PySequence_Check(obj))
tmp=getitem_sequence(obj, index);
else
/* not a sequence */
tmp=getitem_idx(obj, index);
if (tmp==NULL)
 goto error;

/* assign to obj */
Py_SETREF(obj, tmp);
 }
/* end of iterator, this is the non-error case */
if (ok==1)
returnobj;
error:
Py_XDECREF(obj);
returnNULL;
}

/************************************************************************/
/***************** Field rendering functions **************************/
/************************************************************************/

/*
 render_field() is the main function in this section. It takes the
 field object and field specification string generated by
 get_field_and_spec, and renders the field into the output string.

 render_field calls fieldobj.__format__(format_spec) method, and
 appends to the output.
*/
staticint
render_field(PyObject*fieldobj, SubString*format_spec, _PyUnicodeWriter*writer)
{
intok=0;
PyObject*result=NULL;
PyObject*format_spec_object=NULL;
int (*formatter) (_PyUnicodeWriter*, PyObject*, PyObject*, Py_ssize_t, Py_ssize_t) =NULL;
interr;

/* If we know the type exactly, skip the lookup of __format__ and just
 call the formatter directly. */
if (PyUnicode_CheckExact(fieldobj))
formatter=_PyUnicode_FormatAdvancedWriter;
elseif (PyLong_CheckExact(fieldobj))
formatter=_PyLong_FormatAdvancedWriter;
elseif (PyFloat_CheckExact(fieldobj))
formatter=_PyFloat_FormatAdvancedWriter;
elseif (PyComplex_CheckExact(fieldobj))
formatter=_PyComplex_FormatAdvancedWriter;

if (formatter) {
/* we know exactly which formatter will be called when __format__ is
 looked up, so call it directly, instead. */
err=formatter(writer, fieldobj, format_spec->str,
format_spec->start, format_spec->end);
return (err==0);
 }
else {
/* We need to create an object out of the pointers we have, because
 __format__ takes a string/unicode object for format_spec. */
if (format_spec->str)
format_spec_object=PyUnicode_Substring(format_spec->str,
format_spec->start,
format_spec->end);
else
format_spec_object=PyUnicode_New(0, 0);
if (format_spec_object==NULL)
 goto done;

result=PyObject_Format(fieldobj, format_spec_object);
 }
if (result==NULL)
 goto done;

if (_PyUnicodeWriter_WriteStr(writer, result) ==-1)
 goto done;
ok=1;

done:
Py_XDECREF(format_spec_object);
Py_XDECREF(result);
returnok;
}

staticint
parse_field(SubString*str, SubString*field_name, SubString*format_spec,
int*format_spec_needs_expanding, Py_UCS4*conversion)
{
/* Note this function works if the field name is zero length,
 which is good. Zero length field names are handled later, in
 field_name_split. */

Py_UCS4c=0;

/* initialize these, as they may be empty */
*conversion='\0';
SubString_init(format_spec, NULL, 0, 0);

/* Search for the field name. it's terminated by the end of
 the string, or a ':' or '!' */
field_name->str=str->str;
field_name->start=str->start;
while (str->start<str->end) {
switch ((c=PyUnicode_READ_CHAR(str->str, str->start++))) {
case'{':
PyErr_SetString(PyExc_ValueError, "unexpected '{' in field name");
return0;
case'[':
for (; str->start<str->end; str->start++)
if (PyUnicode_READ_CHAR(str->str, str->start) ==']')
break;
continue;
case'}':
case':':
case'!':
break;
default:
continue;
 }
break;
 }

field_name->end=str->start-1;
if (c=='!'||c==':') {
Py_ssize_tcount;
/* we have a format specifier and/or a conversion */
/* don't include the last character */

/* see if there's a conversion specifier */
if (c=='!') {
/* there must be another character present */
if (str->start >= str->end) {
PyErr_SetString(PyExc_ValueError,
"end of string while looking for conversion "
"specifier");
return0;
 }
*conversion=PyUnicode_READ_CHAR(str->str, str->start++);

if (str->start<str->end) {
c=PyUnicode_READ_CHAR(str->str, str->start++);
if (c=='}')
return1;
if (c!=':') {
PyErr_SetString(PyExc_ValueError,
"expected ':' after conversion specifier");
return0;
 }
 }
 }
format_spec->str=str->str;
format_spec->start=str->start;
count=1;
while (str->start<str->end) {
switch ((c=PyUnicode_READ_CHAR(str->str, str->start++))) {
case'{':
*format_spec_needs_expanding=1;
count++;
break;
case'}':
count--;
if (count==0) {
format_spec->end=str->start-1;
return1;
 }
break;
default:
break;
 }
 }

PyErr_SetString(PyExc_ValueError, "unmatched '{' in format spec");
return0;
 }
elseif (c!='}') {
PyErr_SetString(PyExc_ValueError, "expected '}' before end of string");
return0;
 }

return1;
}

/************************************************************************/
/******* Output string allocation and escape-to-markup processing ******/
/************************************************************************/

/* MarkupIterator breaks the string into pieces of either literal
 text, or things inside {} that need to be marked up. it is
 designed to make it easy to wrap a Python iterator around it, for
 use with the Formatter class */

typedefstruct {
SubStringstr;
} MarkupIterator;

staticint
MarkupIterator_init(MarkupIterator*self, PyObject*str,
Py_ssize_tstart, Py_ssize_tend)
{
SubString_init(&self->str, str, start, end);
return1;
}

/* returns 0 on error, 1 on non-error termination, and 2 if it got a
 string (or something to be expanded) */
staticint
MarkupIterator_next(MarkupIterator*self, SubString*literal,
int*field_present, SubString*field_name,
SubString*format_spec, Py_UCS4*conversion,
int*format_spec_needs_expanding)
{
intat_end;
Py_UCS4c=0;
Py_ssize_tstart;
Py_ssize_tlen;
intmarkup_follows=0;

/* initialize all of the output variables */
SubString_init(literal, NULL, 0, 0);
SubString_init(field_name, NULL, 0, 0);
SubString_init(format_spec, NULL, 0, 0);
*conversion='\0';
*format_spec_needs_expanding=0;
*field_present=0;

/* No more input, end of iterator. This is the normal exit
 path. */
if (self->str.start >= self->str.end)
return1;

start=self->str.start;

/* First read any literal text. Read until the end of string, an
 escaped '{' or '}', or an unescaped '{'. In order to never
 allocate memory and so I can just pass pointers around, if
 there's an escaped '{' or '}' then we'll return the literal
 including the brace, but no format object. The next time
 through, we'll return the rest of the literal, skipping past
 the second consecutive brace. */
while (self->str.start<self->str.end) {
switch (c=PyUnicode_READ_CHAR(self->str.str, self->str.start++)) {
case'{':
case'}':
markup_follows=1;
break;
default:
continue;
 }
break;
 }

at_end=self->str.start >= self->str.end;
len=self->str.start-start;

if ((c=='}') && (at_end||
 (c!=PyUnicode_READ_CHAR(self->str.str,
self->str.start)))) {
PyErr_SetString(PyExc_ValueError, "Single '}' encountered "
"in format string");
return0;
 }
if (at_end&&c=='{') {
PyErr_SetString(PyExc_ValueError, "Single '{' encountered "
"in format string");
return0;
 }
if (!at_end) {
if (c==PyUnicode_READ_CHAR(self->str.str, self->str.start)) {
/* escaped } or {, skip it in the input. there is no
 markup object following us, just this literal text */
self->str.start++;
markup_follows=0;
 }
else
len--;
 }

/* record the literal text */
literal->str=self->str.str;
literal->start=start;
literal->end=start+len;

if (!markup_follows)
return2;

/* this is markup; parse the field */
*field_present=1;
if (!parse_field(&self->str, field_name, format_spec,
format_spec_needs_expanding, conversion))
return0;
return2;
}


/* do the !r or !s conversion on obj */
staticPyObject*
do_conversion(PyObject*obj, Py_UCS4conversion)
{
/* XXX in pre-3.0, do we need to convert this to unicode, since it
 might have returned a string? */
switch (conversion) {
case'r':
returnPyObject_Repr(obj);
case's':
returnPyObject_Str(obj);
case'a':
returnPyObject_ASCII(obj);
default:
if (conversion>32&&conversion<127) {
/* It's the ASCII subrange; casting to char is safe
 (assuming the execution character set is an ASCII
 superset). */
PyErr_Format(PyExc_ValueError,
"Unknown conversion specifier %c",
 (char)conversion);
 } else
PyErr_Format(PyExc_ValueError,
"Unknown conversion specifier \\x%x",
 (unsigned int)conversion);
returnNULL;
 }
}

/* given:

 {field_name!conversion:format_spec}

 compute the result and write it to output.
 format_spec_needs_expanding is an optimization. if it's false,
 just output the string directly, otherwise recursively expand the
 format_spec string.

 field_name is allowed to be zero length, in which case we
 are doing auto field numbering.
*/

staticint
output_markup(SubString*field_name, SubString*format_spec,
intformat_spec_needs_expanding, Py_UCS4conversion,
_PyUnicodeWriter*writer, PyObject*args, PyObject*kwargs,
intrecursion_depth, AutoNumber*auto_number)
{
PyObject*tmp=NULL;
PyObject*fieldobj=NULL;
SubStringexpanded_format_spec;
SubString*actual_format_spec;
intresult=0;

/* convert field_name to an object */
fieldobj=get_field_object(field_name, args, kwargs, auto_number);
if (fieldobj==NULL)
 goto done;

if (conversion!='\0') {
tmp=do_conversion(fieldobj, conversion);
if (tmp==NULL)
 goto done;

/* do the assignment, transferring ownership: fieldobj = tmp */
Py_SETREF(fieldobj, tmp);
tmp=NULL;
 }

/* if needed, recursively compute the format_spec */
if (format_spec_needs_expanding) {
tmp=build_string(format_spec, args, kwargs, recursion_depth-1,
auto_number);
if (tmp==NULL)
 goto done;

/* note that in the case we're expanding the format string,
 tmp must be kept around until after the call to
 render_field. */
SubString_init(&expanded_format_spec, tmp, 0, PyUnicode_GET_LENGTH(tmp));
actual_format_spec=&expanded_format_spec;
 }
else
actual_format_spec=format_spec;

if (render_field(fieldobj, actual_format_spec, writer) ==0)
 goto done;

result=1;

done:
Py_XDECREF(fieldobj);
Py_XDECREF(tmp);

returnresult;
}

/*
 do_markup is the top-level loop for the format() method. It
 searches through the format string for escapes to markup codes, and
 calls other functions to move non-markup text to the output,
 and to perform the markup to the output.
*/
staticint
do_markup(SubString*input, PyObject*args, PyObject*kwargs,
_PyUnicodeWriter*writer, intrecursion_depth, AutoNumber*auto_number)
{
MarkupIteratoriter;
intformat_spec_needs_expanding;
intresult;
intfield_present;
SubStringliteral;
SubStringfield_name;
SubStringformat_spec;
Py_UCS4conversion;

MarkupIterator_init(&iter, input->str, input->start, input->end);
while ((result=MarkupIterator_next(&iter, &literal, &field_present,
&field_name, &format_spec,
&conversion,
&format_spec_needs_expanding)) ==2) {
if (literal.end!=literal.start) {
if (!field_present&&iter.str.start==iter.str.end)
writer->overallocate=0;
if (_PyUnicodeWriter_WriteSubstring(writer, literal.str,
literal.start, literal.end) <0)
return0;
 }

if (field_present) {
if (iter.str.start==iter.str.end)
writer->overallocate=0;
if (!output_markup(&field_name, &format_spec,
format_spec_needs_expanding, conversion, writer,
args, kwargs, recursion_depth, auto_number))
return0;
 }
 }
returnresult;
}


/*
 build_string allocates the output string and then
 calls do_markup to do the heavy lifting.
*/
staticPyObject*
build_string(SubString*input, PyObject*args, PyObject*kwargs,
intrecursion_depth, AutoNumber*auto_number)
{
_PyUnicodeWriterwriter;

/* check the recursion level */
if (recursion_depth <= 0) {
PyErr_SetString(PyExc_ValueError,
"Max string recursion exceeded");
returnNULL;
 }

_PyUnicodeWriter_Init(&writer);
writer.overallocate=1;
writer.min_length=PyUnicode_GET_LENGTH(input->str) +100;

if (!do_markup(input, args, kwargs, &writer, recursion_depth,
auto_number)) {
_PyUnicodeWriter_Dealloc(&writer);
returnNULL;
 }

return_PyUnicodeWriter_Finish(&writer);
}

/************************************************************************/
/*********** main routine ***********************************************/
/************************************************************************/

/* this is the main entry point */
staticPyObject*
do_string_format(PyObject*self, PyObject*args, PyObject*kwargs)
{
SubStringinput;

/* PEP 3101 says only 2 levels, so that
 "{0:{1}}".format('abc', 's') # works
 "{0:{1:{2}}}".format('abc', 's', '') # fails
 */
intrecursion_depth=2;

AutoNumberauto_number;
AutoNumber_Init(&auto_number);
SubString_init(&input, self, 0, PyUnicode_GET_LENGTH(self));
returnbuild_string(&input, args, kwargs, recursion_depth, &auto_number);
}

staticPyObject*
do_string_format_map(PyObject*self, PyObject*obj)
{
returndo_string_format(self, NULL, obj);
}


/************************************************************************/
/*********** formatteriterator ******************************************/
/************************************************************************/

/* This is used to implement string.Formatter.vparse(). It exists so
 Formatter can share code with the built in unicode.format() method.
 It's really just a wrapper around MarkupIterator that is callable
 from Python. */

typedefstruct {
PyObject_HEAD
PyObject*str;
MarkupIteratorit_markup;
} formatteriterobject;

staticvoid
formatteriter_dealloc(formatteriterobject*it)
{
Py_XDECREF(it->str);
PyObject_Free(it);
}

/* returns a tuple:
 (literal, field_name, format_spec, conversion)

 literal is any literal text to output. might be zero length
 field_name is the string before the ':'. might be None
 format_spec is the string after the ':'. mibht be None
 conversion is either None, or the string after the '!'
*/
staticPyObject*
formatteriter_next(formatteriterobject*it)
{
SubStringliteral;
SubStringfield_name;
SubStringformat_spec;
Py_UCS4conversion;