getargs.c

/* New getargs implementation */

#definePY_CXX_CONST const
#include"Python.h"
#include"pycore_abstract.h"// _PyNumber_Index()
#include"pycore_dict.h"// _PyDict_HasOnlyStringKeys()
#include"pycore_modsupport.h"// export _PyArg_NoKeywords()
#include"pycore_pylifecycle.h"// _PyArg_Fini
#include"pycore_pystate.h"// _Py_IsMainInterpreter()
#include"pycore_tuple.h"// _PyTuple_ITEMS()
#include"pycore_pyerrors.h"// _Py_CalculateSuggestions()

/* Export Stable ABIs (abi only) */
PyAPI_FUNC(int) _PyArg_Parse_SizeT(PyObject*, constchar*, ...);
PyAPI_FUNC(int) _PyArg_ParseTuple_SizeT(PyObject*, constchar*, ...);
PyAPI_FUNC(int) _PyArg_ParseTupleAndKeywords_SizeT(PyObject*, PyObject*,
constchar*, constchar*const*, ...);
PyAPI_FUNC(int) _PyArg_VaParse_SizeT(PyObject*, constchar*, va_list);
PyAPI_FUNC(int) _PyArg_VaParseTupleAndKeywords_SizeT(PyObject*, PyObject*,
constchar*, constchar*const*, va_list);

#defineFLAG_COMPAT 1

typedefint (*destr_t)(PyObject*, void*);


/* Keep track of "objects" that have been allocated or initialized and
 which will need to be deallocated or cleaned up somehow if overall
 parsing fails.
*/
typedefstruct {
void*item;
destr_tdestructor;
} freelistentry_t;

typedefstruct {
freelistentry_t*entries;
intfirst_available;
intentries_malloced;
} freelist_t;

#defineSTATIC_FREELIST_ENTRIES 8

/* Forward */
staticintvgetargs1_impl(PyObject*args, PyObject*const*stack, Py_ssize_tnargs,
constchar*format, va_list*p_va, intflags);
staticintvgetargs1(PyObject*, constchar*, va_list*, int);
staticvoidseterror(Py_ssize_t, constchar*, int*, constchar*, constchar*);
staticconstchar*convertitem(PyObject*, constchar**, va_list*, int, int*,
char*, size_t, freelist_t*);
staticconstchar*converttuple(PyObject*, constchar**, va_list*, int,
int*, char*, size_t, freelist_t*);
staticconstchar*convertsimple(PyObject*, constchar**, va_list*, int,
char*, size_t, freelist_t*);
staticPy_ssize_tconvertbuffer(PyObject*, constvoid**p, constchar**);
staticintgetbuffer(PyObject*, Py_buffer*, constchar**);

staticintvgetargskeywords(PyObject*, PyObject*,
constchar*, constchar*const*, va_list*, int);
staticintvgetargskeywordsfast(PyObject*, PyObject*,
struct_PyArg_Parser*, va_list*, int);
staticintvgetargskeywordsfast_impl(PyObject*const*args, Py_ssize_tnargs,
PyObject*keywords, PyObject*kwnames,
struct_PyArg_Parser*parser,
va_list*p_va, intflags);
staticconstchar*skipitem(constchar**, va_list*, int);

int
PyArg_Parse(PyObject*args, constchar*format, ...)
{
intretval;
va_listva;

va_start(va, format);
retval=vgetargs1(args, format, &va, FLAG_COMPAT);
va_end(va);
returnretval;
}

PyAPI_FUNC(int)
_PyArg_Parse_SizeT(PyObject*args, constchar*format, ...)
{
intretval;
va_listva;

va_start(va, format);
retval=vgetargs1(args, format, &va, FLAG_COMPAT);
va_end(va);
returnretval;
}


int
PyArg_ParseTuple(PyObject*args, constchar*format, ...)
{
intretval;
va_listva;

va_start(va, format);
retval=vgetargs1(args, format, &va, 0);
va_end(va);
returnretval;
}

int
_PyArg_ParseTuple_SizeT(PyObject*args, constchar*format, ...)
{
intretval;
va_listva;

va_start(va, format);
retval=vgetargs1(args, format, &va, 0);
va_end(va);
returnretval;
}


int
_PyArg_ParseStack(PyObject*const*args, Py_ssize_tnargs, constchar*format, ...)
{
intretval;
va_listva;

va_start(va, format);
retval=vgetargs1_impl(NULL, args, nargs, format, &va, 0);
va_end(va);
returnretval;
}

int
PyArg_VaParse(PyObject*args, constchar*format, va_listva)
{
va_listlva;
intretval;

va_copy(lva, va);

retval=vgetargs1(args, format, &lva, 0);
va_end(lva);
returnretval;
}

int
_PyArg_VaParse_SizeT(PyObject*args, constchar*format, va_listva)
{
va_listlva;
intretval;

va_copy(lva, va);

retval=vgetargs1(args, format, &lva, 0);
va_end(lva);
returnretval;
}


/* Handle cleanup of allocated memory in case of exception */

staticint
cleanup_ptr(PyObject*self, void*ptr)
{
void**pptr= (void**)ptr;
PyMem_Free(*pptr);
*pptr=NULL;
return0;
}

staticint
cleanup_buffer(PyObject*self, void*ptr)
{
Py_buffer*buf= (Py_buffer*)ptr;
if (buf) {
PyBuffer_Release(buf);
 }
return0;
}

staticint
addcleanup(void*ptr, freelist_t*freelist, destr_tdestructor)
{
intindex;

index=freelist->first_available;
freelist->first_available+=1;

freelist->entries[index].item=ptr;
freelist->entries[index].destructor=destructor;

return0;
}

staticint
cleanreturn(intretval, freelist_t*freelist)
{
intindex;

if (retval==0) {
/* A failure occurred, therefore execute all of the cleanup
 functions.
 */
for (index=0; index<freelist->first_available; ++index) {
freelist->entries[index].destructor(NULL,
freelist->entries[index].item);
 }
 }
if (freelist->entries_malloced)
PyMem_Free(freelist->entries);
returnretval;
}


staticint
vgetargs1_impl(PyObject*compat_args, PyObject*const*stack, Py_ssize_tnargs, constchar*format,
va_list*p_va, intflags)
{
charmsgbuf[256];
intlevels[32];
constchar*fname=NULL;
constchar*message=NULL;
intmin=-1;
intmax=0;
intlevel=0;
intendfmt=0;
constchar*formatsave=format;
Py_ssize_ti;
constchar*msg;
intcompat=flags&FLAG_COMPAT;
freelistentry_tstatic_entries[STATIC_FREELIST_ENTRIES];
freelist_tfreelist;

assert(nargs==0||stack!=NULL);

freelist.entries=static_entries;
freelist.first_available=0;
freelist.entries_malloced=0;

flags=flags& ~FLAG_COMPAT;

while (endfmt==0) {
intc=*format++;
switch (c) {
case'(':
if (level==0)
max++;
level++;
if (level >= 30)
Py_FatalError("too many tuple nesting levels "
"in argument format string");
break;
case')':
if (level==0)
Py_FatalError("excess ')' in getargs format");
else
level--;
break;
case'\0':
endfmt=1;
break;
case':':
fname=format;
endfmt=1;
break;
case';':
message=format;
endfmt=1;
break;
case'|':
if (level==0)
min=max;
break;
default:
if (level==0) {
if (Py_ISALPHA(c))
if (c!='e') /* skip encoded */
max++;
 }
break;
 }
 }

if (level!=0)
Py_FatalError(/* '(' */"missing ')' in getargs format");

if (min<0)
min=max;

format=formatsave;

if (max>STATIC_FREELIST_ENTRIES) {
freelist.entries=PyMem_NEW(freelistentry_t, max);
if (freelist.entries==NULL) {
PyErr_NoMemory();
return0;
 }
freelist.entries_malloced=1;
 }

if (compat) {
if (max==0) {
if (compat_args==NULL)
return1;
PyErr_Format(PyExc_TypeError,
"%.200s%s takes no arguments",
fname==NULL ? "function" : fname,
fname==NULL ? "" : "()");
returncleanreturn(0, &freelist);
 }
elseif (min==1&&max==1) {
if (compat_args==NULL) {
PyErr_Format(PyExc_TypeError,
"%.200s%s takes at least one argument",
fname==NULL ? "function" : fname,
fname==NULL ? "" : "()");
returncleanreturn(0, &freelist);
 }
msg=convertitem(compat_args, &format, p_va, flags, levels,
msgbuf, sizeof(msgbuf), &freelist);
if (msg==NULL)
returncleanreturn(1, &freelist);
seterror(levels[0], msg, levels+1, fname, message);
returncleanreturn(0, &freelist);
 }
else {
PyErr_SetString(PyExc_SystemError,
"old style getargs format uses new features");
returncleanreturn(0, &freelist);
 }
 }

if (nargs<min||max<nargs) {
if (message==NULL)
PyErr_Format(PyExc_TypeError,
"%.150s%s takes %s %d argument%s (%zd given)",
fname==NULL ? "function" : fname,
fname==NULL ? "" : "()",
min==max ? "exactly"
 : nargs<min ? "at least" : "at most",
nargs<min ? min : max,
 (nargs<min ? min : max) ==1 ? "" : "s",
nargs);
else
PyErr_SetString(PyExc_TypeError, message);
returncleanreturn(0, &freelist);
 }

for (i=0; i<nargs; i++) {
if (*format=='|')
format++;
msg=convertitem(stack[i], &format, p_va,
flags, levels, msgbuf,
sizeof(msgbuf), &freelist);
if (msg) {
seterror(i+1, msg, levels, fname, message);
returncleanreturn(0, &freelist);
 }
 }

if (*format!='\0'&& !Py_ISALPHA(*format) &&
*format!='('&&
*format!='|'&&*format!=':'&&*format!=';') {
PyErr_Format(PyExc_SystemError,
"bad format string: %.200s", formatsave);
returncleanreturn(0, &freelist);
 }

returncleanreturn(1, &freelist);
}

staticint
vgetargs1(PyObject*args, constchar*format, va_list*p_va, intflags)
{
PyObject**stack;
Py_ssize_tnargs;

if (!(flags&FLAG_COMPAT)) {
assert(args!=NULL);

if (!PyTuple_Check(args)) {
PyErr_SetString(PyExc_SystemError,
"new style getargs format but argument is not a tuple");
return0;
 }

stack=_PyTuple_ITEMS(args);
nargs=PyTuple_GET_SIZE(args);
 }
else {
stack=NULL;
nargs=0;
 }

returnvgetargs1_impl(args, stack, nargs, format, p_va, flags);
}


staticvoid
seterror(Py_ssize_tiarg, constchar*msg, int*levels, constchar*fname,
constchar*message)
{
charbuf[512];
inti;
char*p=buf;

if (PyErr_Occurred())
return;
elseif (message==NULL) {
if (fname!=NULL) {
PyOS_snprintf(p, sizeof(buf), "%.200s() ", fname);
p+=strlen(p);
 }
if (iarg!=0) {
PyOS_snprintf(p, sizeof(buf) - (p-buf),
"argument %zd", iarg);
i=0;
p+=strlen(p);
while (i<32&&levels[i] >0&& (int)(p-buf) <220) {
PyOS_snprintf(p, sizeof(buf) - (p-buf),
", item %d", levels[i]-1);
p+=strlen(p);
i++;
 }
 }
else {
PyOS_snprintf(p, sizeof(buf) - (p-buf), "argument");
p+=strlen(p);
 }
PyOS_snprintf(p, sizeof(buf) - (p-buf), " %.256s", msg);
message=buf;
 }
if (msg[0] =='(') {
PyErr_SetString(PyExc_SystemError, message);
 }
else {
PyErr_SetString(PyExc_TypeError, message);
 }
}


/* Convert a tuple argument.
 On entry, *p_format points to the character _after_ the opening '('.
 On successful exit, *p_format points to the closing ')'.
 If successful:
 *p_format and *p_va are updated,
 *levels and *msgbuf are untouched,
 and NULL is returned.
 If the argument is invalid:
 *p_format is unchanged,
 *p_va is undefined,
 *levels is a 0-terminated list of item numbers,
 *msgbuf contains an error message, whose format is:
 "must be <typename1>, not <typename2>", where:
 <typename1> is the name of the expected type, and
 <typename2> is the name of the actual type,
 and msgbuf is returned.
*/

staticconstchar*
converttuple(PyObject*arg, constchar**p_format, va_list*p_va, intflags,
int*levels, char*msgbuf, size_tbufsize,
freelist_t*freelist)
{
intlevel=0;
intn=0;
constchar*format=*p_format;
inti;
Py_ssize_tlen;

for (;;) {
intc=*format++;
if (c=='(') {
if (level==0)
n++;
level++;
 }
elseif (c==')') {
if (level==0)
break;
level--;
 }
elseif (c==':'||c==';'||c=='\0')
break;
elseif (level==0&&Py_ISALPHA(c) &&c!='e')
n++;
 }

if (!PySequence_Check(arg) ||PyBytes_Check(arg)) {
levels[0] =0;
PyOS_snprintf(msgbuf, bufsize,
"must be %d-item sequence, not %.50s",
n,
arg==Py_None ? "None" : Py_TYPE(arg)->tp_name);
returnmsgbuf;
 }

len=PySequence_Size(arg);
if (len!=n) {
levels[0] =0;
PyOS_snprintf(msgbuf, bufsize,
"must be sequence of length %d, not %zd",
n, len);
returnmsgbuf;
 }

format=*p_format;
for (i=0; i<n; i++) {
constchar*msg;
PyObject*item;
item=PySequence_GetItem(arg, i);
if (item==NULL) {
PyErr_Clear();
levels[0] =i+1;
levels[1] =0;
strncpy(msgbuf, "is not retrievable", bufsize);
returnmsgbuf;
 }
msg=convertitem(item, &format, p_va, flags, levels+1,
msgbuf, bufsize, freelist);
/* PySequence_GetItem calls tp->sq_item, which INCREFs */
Py_XDECREF(item);
if (msg!=NULL) {
levels[0] =i+1;
returnmsg;
 }
 }

*p_format=format;
returnNULL;
}


/* Convert a single item. */

staticconstchar*
convertitem(PyObject*arg, constchar**p_format, va_list*p_va, intflags,
int*levels, char*msgbuf, size_tbufsize, freelist_t*freelist)
{
constchar*msg;
constchar*format=*p_format;

if (*format=='('/* ')' */) {
format++;
msg=converttuple(arg, &format, p_va, flags, levels, msgbuf,
bufsize, freelist);
if (msg==NULL)
format++;
 }
else {
msg=convertsimple(arg, &format, p_va, flags,
msgbuf, bufsize, freelist);
if (msg!=NULL)
levels[0] =0;
 }
if (msg==NULL)
*p_format=format;
returnmsg;
}



/* Format an error message generated by convertsimple().
 displayname must be UTF-8 encoded.
*/

void
_PyArg_BadArgument(constchar*fname, constchar*displayname,
constchar*expected, PyObject*arg)
{
PyErr_Format(PyExc_TypeError,
"%.200s() %.200s must be %.50s, not %.50s",
fname, displayname, expected,
arg==Py_None ? "None" : Py_TYPE(arg)->tp_name);
}

staticconstchar*
converterr(constchar*expected, PyObject*arg, char*msgbuf, size_tbufsize)
{
assert(expected!=NULL);
assert(arg!=NULL);
if (expected[0] =='(') {
PyOS_snprintf(msgbuf, bufsize,
"%.100s", expected);
 }
else {
PyOS_snprintf(msgbuf, bufsize,
"must be %.50s, not %.50s", expected,
arg==Py_None ? "None" : Py_TYPE(arg)->tp_name);
 }
returnmsgbuf;
}

#defineCONV_UNICODE "(unicode conversion error)"

/* Convert a non-tuple argument. Return NULL if conversion went OK,
 or a string with a message describing the failure. The message is
 formatted as "must be <desired type>, not <actual type>".
 When failing, an exception may or may not have been raised.
 Don't call if a tuple is expected.

 When you add new format codes, please don't forget poor skipitem() below.
*/

staticconstchar*
convertsimple(PyObject*arg, constchar**p_format, va_list*p_va, intflags,
char*msgbuf, size_tbufsize, freelist_t*freelist)
{
#defineRETURN_ERR_OCCURRED return msgbuf

constchar*format=*p_format;
charc=*format++;
constchar*sarg;

switch (c) {

case'b': { /* unsigned byte -- very short int */
unsigned char*p=va_arg(*p_va, unsignedchar*);
longival=PyLong_AsLong(arg);
if (ival==-1&&PyErr_Occurred())
RETURN_ERR_OCCURRED;
elseif (ival<0) {
PyErr_SetString(PyExc_OverflowError,
"unsigned byte integer is less than minimum");
RETURN_ERR_OCCURRED;
 }
elseif (ival>UCHAR_MAX) {
PyErr_SetString(PyExc_OverflowError,
"unsigned byte integer is greater than maximum");
RETURN_ERR_OCCURRED;
 }
else
*p= (unsigned char) ival;
break;
 }

case'B': {/* byte sized bitfield - both signed and unsigned
 values allowed */
unsigned char*p=va_arg(*p_va, unsignedchar*);
unsigned longival=PyLong_AsUnsignedLongMask(arg);
if (ival== (unsigned long)-1&&PyErr_Occurred())
RETURN_ERR_OCCURRED;
else
*p= (unsigned char) ival;
break;
 }

case'h': {/* signed short int */
short*p=va_arg(*p_va, short*);
longival=PyLong_AsLong(arg);
if (ival==-1&&PyErr_Occurred())
RETURN_ERR_OCCURRED;
elseif (ival<SHRT_MIN) {
PyErr_SetString(PyExc_OverflowError,
"signed short integer is less than minimum");
RETURN_ERR_OCCURRED;
 }
elseif (ival>SHRT_MAX) {
PyErr_SetString(PyExc_OverflowError,
"signed short integer is greater than maximum");
RETURN_ERR_OCCURRED;
 }
else
*p= (short) ival;
break;
 }

case'H': { /* short int sized bitfield, both signed and
 unsigned allowed */
unsigned short*p=va_arg(*p_va, unsignedshort*);
unsigned longival=PyLong_AsUnsignedLongMask(arg);
if (ival== (unsigned long)-1&&PyErr_Occurred())
RETURN_ERR_OCCURRED;
else
*p= (unsigned short) ival;
break;
 }

case'i': {/* signed int */
int*p=va_arg(*p_va, int*);
longival=PyLong_AsLong(arg);
if (ival==-1&&PyErr_Occurred())
RETURN_ERR_OCCURRED;
elseif (ival>INT_MAX) {
PyErr_SetString(PyExc_OverflowError,
"signed integer is greater than maximum");
RETURN_ERR_OCCURRED;
 }
elseif (ival<INT_MIN) {
PyErr_SetString(PyExc_OverflowError,
"signed integer is less than minimum");
RETURN_ERR_OCCURRED;
 }
else
*p=ival;
break;
 }

case'I': { /* int sized bitfield, both signed and
 unsigned allowed */
unsigned int*p=va_arg(*p_va, unsignedint*);
unsigned longival=PyLong_AsUnsignedLongMask(arg);
if (ival== (unsigned long)-1&&PyErr_Occurred())
RETURN_ERR_OCCURRED;
else
*p= (unsigned int) ival;
break;
 }

case'n': /* Py_ssize_t */
 {
PyObject*iobj;
Py_ssize_t*p=va_arg(*p_va, Py_ssize_t*);
Py_ssize_tival=-1;
iobj=_PyNumber_Index(arg);
if (iobj!=NULL) {
ival=PyLong_AsSsize_t(iobj);
Py_DECREF(iobj);
 }
if (ival==-1&&PyErr_Occurred())
RETURN_ERR_OCCURRED;
*p=ival;
break;
 }
case'l': {/* long int */
long*p=va_arg(*p_va, long*);
longival=PyLong_AsLong(arg);
if (ival==-1&&PyErr_Occurred())
RETURN_ERR_OCCURRED;
else
*p=ival;
break;
 }

case'k': { /* long sized bitfield */
unsigned long*p=va_arg(*p_va, unsignedlong*);
unsigned longival;
if (PyLong_Check(arg))
ival=PyLong_AsUnsignedLongMask(arg);
else
returnconverterr("int", arg, msgbuf, bufsize);
*p=ival;
break;
 }

case'L': {/* long long */
long long*p=va_arg( *p_va, longlong* );
long longival=PyLong_AsLongLong(arg);
if (ival== (long long)-1&&PyErr_Occurred())
RETURN_ERR_OCCURRED;
else
*p=ival;
break;
 }

case'K': { /* long long sized bitfield */
unsigned long long*p=va_arg(*p_va, unsignedlong long *);
unsigned long longival;
if (PyLong_Check(arg))
ival=PyLong_AsUnsignedLongLongMask(arg);
else
returnconverterr("int", arg, msgbuf, bufsize);
*p=ival;
break;
 }

case'f': {/* float */
float*p=va_arg(*p_va, float*);
doubledval=PyFloat_AsDouble(arg);
if (dval==-1.0&&PyErr_Occurred())
RETURN_ERR_OCCURRED;
else
*p= (float) dval;
break;
 }

case'd': {/* double */
double*p=va_arg(*p_va, double*);
doubledval=PyFloat_AsDouble(arg);
if (dval==-1.0&&PyErr_Occurred())
RETURN_ERR_OCCURRED;
else
*p=dval;
break;
 }

case'D': {/* complex double */
Py_complex*p=va_arg(*p_va, Py_complex*);
Py_complexcval;
cval=PyComplex_AsCComplex(arg);
if (PyErr_Occurred())
RETURN_ERR_OCCURRED;
else
*p=cval;
break;
 }

case'c': {/* char */
char*p=va_arg(*p_va, char*);
if (PyBytes_Check(arg) &&PyBytes_Size(arg) ==1)
*p=PyBytes_AS_STRING(arg)[0];
elseif (PyByteArray_Check(arg) &&PyByteArray_Size(arg) ==1)
*p=PyByteArray_AS_STRING(arg)[0];
else
returnconverterr("a byte string of length 1", arg, msgbuf, bufsize);
break;
 }

case'C': {/* unicode char */
int*p=va_arg(*p_va, int*);
intkind;
constvoid*data;

if (!PyUnicode_Check(arg))
returnconverterr("a unicode character", arg, msgbuf, bufsize);

if (PyUnicode_GET_LENGTH(arg) !=1)
returnconverterr("a unicode character", arg, msgbuf, bufsize);

kind=PyUnicode_KIND(arg);
data=PyUnicode_DATA(arg);
*p=PyUnicode_READ(kind, data, 0);
break;
 }

case'p': {/* boolean *p*redicate */
int*p=va_arg(*p_va, int*);
intval=PyObject_IsTrue(arg);
if (val>0)
*p=1;
elseif (val==0)
*p=0;
else
RETURN_ERR_OCCURRED;
break;
 }

/* XXX WAAAAH! 's', 'y', 'z', 'u', 'Z', 'e', 'w' codes all
 need to be cleaned up! */

case'y': {/* any bytes-like object */
void**p= (void**)va_arg(*p_va, char**);
constchar*buf;
Py_ssize_tcount;
if (*format=='*') {
if (getbuffer(arg, (Py_buffer*)p, &buf) <0)
returnconverterr(buf, arg, msgbuf, bufsize);
format++;
if (addcleanup(p, freelist, cleanup_buffer)) {
returnconverterr(
"(cleanup problem)",
arg, msgbuf, bufsize);
 }
break;
 }
count=convertbuffer(arg, (constvoid**)p, &buf);
if (count<0)
returnconverterr(buf, arg, msgbuf, bufsize);
if (*format=='#') {
Py_ssize_t*psize=va_arg(*p_va, Py_ssize_t*);
*psize=count;
format++;
 } else {
if (strlen(*p) != (size_t)count) {
PyErr_SetString(PyExc_ValueError, "embedded null byte");
RETURN_ERR_OCCURRED;
 }
 }
break;
 }

case's': /* text string or bytes-like object */
case'z': /* text string, bytes-like object or None */
 {
if (*format=='*') {
/* "s*" or "z*" */
Py_buffer*p= (Py_buffer*)va_arg(*p_va, Py_buffer*);

if (c=='z'&&arg==Py_None)
PyBuffer_FillInfo(p, NULL, NULL, 0, 1, 0);
elseif (PyUnicode_Check(arg)) {
Py_ssize_tlen;
sarg=PyUnicode_AsUTF8AndSize(arg, &len);
if (sarg==NULL)
returnconverterr(CONV_UNICODE,
arg, msgbuf, bufsize);
PyBuffer_FillInfo(p, arg, (void*)sarg, len, 1, 0);
 }
else { /* any bytes-like object */
constchar*buf;
if (getbuffer(arg, p, &buf) <0)
returnconverterr(buf, arg, msgbuf, bufsize);
 }
if (addcleanup(p, freelist, cleanup_buffer)) {
returnconverterr(
"(cleanup problem)",
arg, msgbuf, bufsize);
 }
format++;
 } elseif (*format=='#') { /* a string or read-only bytes-like object */
/* "s#" or "z#" */
constvoid**p= (constvoid**)va_arg(*p_va, constchar**);
Py_ssize_t*psize=va_arg(*p_va, Py_ssize_t*);

if (c=='z'&&arg==Py_None) {
*p=NULL;
*psize=0;
 }
elseif (PyUnicode_Check(arg)) {
Py_ssize_tlen;
sarg=PyUnicode_AsUTF8AndSize(arg, &len);
if (sarg==NULL)
returnconverterr(CONV_UNICODE,
arg, msgbuf, bufsize);
*p=sarg;
*psize=len;
 }
else { /* read-only bytes-like object */
/* XXX Really? */
constchar*buf;
Py_ssize_tcount=convertbuffer(arg, p, &buf);
if (count<0)
returnconverterr(buf, arg, msgbuf, bufsize);
*psize=count;
 }
format++;
 } else {
/* "s" or "z" */
constchar**p=va_arg(*p_va, constchar**);
Py_ssize_tlen;
sarg=NULL;

if (c=='z'&&arg==Py_None)
*p=NULL;
elseif (PyUnicode_Check(arg)) {
sarg=PyUnicode_AsUTF8AndSize(arg, &len);
if (sarg==NULL)
returnconverterr(CONV_UNICODE,
arg, msgbuf, bufsize);
if (strlen(sarg) != (size_t)len) {
PyErr_SetString(PyExc_ValueError, "embedded null character");
RETURN_ERR_OCCURRED;
 }
*p=sarg;
 }
else
returnconverterr(c=='z' ? "str or None" : "str",
arg, msgbuf, bufsize);
 }
break;
 }

case'e': {/* encoded string */
char**buffer;
constchar*encoding;
PyObject*s;
intrecode_strings;
Py_ssize_tsize;
constchar*ptr;

/* Get 'e' parameter: the encoding name */
encoding= (constchar*)va_arg(*p_va, constchar*);
if (encoding==NULL)
encoding=PyUnicode_GetDefaultEncoding();

/* Get output buffer parameter:
 's' (recode all objects via Unicode) or
 't' (only recode non-string objects)
 */
if (*format=='s')
recode_strings=1;
elseif (*format=='t')
recode_strings=0;
else
returnconverterr(
"(unknown parser marker combination)",
arg, msgbuf, bufsize);
buffer= (char**)va_arg(*p_va, char**);
format++;
if (buffer==NULL)
returnconverterr("(buffer is NULL)",
arg, msgbuf, bufsize);

/* Encode object */
if (!recode_strings&&
 (PyBytes_Check(arg) ||PyByteArray_Check(arg))) {
s=Py_NewRef(arg);
if (PyBytes_Check(arg)) {
size=PyBytes_GET_SIZE(s);
ptr=PyBytes_AS_STRING(s);
 }
else {
size=PyByteArray_GET_SIZE(s);
ptr=PyByteArray_AS_STRING(s);
 }
 }
elseif (PyUnicode_Check(arg)) {
/* Encode object; use default error handling */
s=PyUnicode_AsEncodedString(arg,
encoding,
NULL);
if (s==NULL)