/* New getargs implementation */

#include "Python.h"

#include "pycore_tupleobject.h"

#include <ctype.h>

#include <float.h>

#ifdef __cplusplus

extern "C" {

#endif

int PyArg_Parse(PyObject *, const char *, ...);

int PyArg_ParseTuple(PyObject *, const char *, ...);

int PyArg_VaParse(PyObject *, const char *, va_list);

int PyArg_ParseTupleAndKeywords(PyObject *, PyObject *,

const char *, char **, ...);

int PyArg_VaParseTupleAndKeywords(PyObject *, PyObject *,

const char *, char **, va_list);

int _PyArg_ParseTupleAndKeywordsFast(PyObject *, PyObject *,

struct _PyArg_Parser *, ...);

int _PyArg_VaParseTupleAndKeywordsFast(PyObject *, PyObject *,

struct _PyArg_Parser *, va_list);

#ifdef HAVE_DECLSPEC_DLL

/* Export functions */

PyAPI_FUNC(int) _PyArg_Parse_SizeT(PyObject *, const char *, ...);

PyAPI_FUNC(int) _PyArg_ParseStack_SizeT(PyObject *const *args, Py_ssize_t nargs,

const char *format, ...);

PyAPI_FUNC(int) _PyArg_ParseStackAndKeywords_SizeT(PyObject *const *args, Py_ssize_t nargs,

PyObject *kwnames,

struct _PyArg_Parser *parser, ...);

PyAPI_FUNC(int) _PyArg_ParseTuple_SizeT(PyObject *, const char *, ...);

PyAPI_FUNC(int) _PyArg_ParseTupleAndKeywords_SizeT(PyObject *, PyObject *,

const char *, char **, ...);

PyAPI_FUNC(PyObject *) _Py_BuildValue_SizeT(const char *, ...);

PyAPI_FUNC(int) _PyArg_VaParse_SizeT(PyObject *, const char *, va_list);

PyAPI_FUNC(int) _PyArg_VaParseTupleAndKeywords_SizeT(PyObject *, PyObject *,

const char *, char **, va_list);

PyAPI_FUNC(int) _PyArg_ParseTupleAndKeywordsFast_SizeT(PyObject *, PyObject *,

struct _PyArg_Parser *, ...);

PyAPI_FUNC(int) _PyArg_VaParseTupleAndKeywordsFast_SizeT(PyObject *, PyObject *,

struct _PyArg_Parser *, va_list);

#endif

#define FLAG_COMPAT 1

#define FLAG_SIZE_T 2

typedef int (*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.

*/

typedef struct {

void *item;

destr_t destructor;

} freelistentry_t;

typedef struct {

freelistentry_t *entries;

int first_available;

int entries_malloced;

} freelist_t;

#define STATIC_FREELIST_ENTRIES 8

/* Forward */

static int vgetargs1_impl(PyObject *args, PyObject *const *stack, Py_ssize_t nargs,

const char *format, va_list *p_va, int flags);

static int vgetargs1(PyObject *, const char *, va_list *, int);

static void seterror(Py_ssize_t, const char *, int *, const char *, const char *);

static const char *convertitem(PyObject *, const char **, va_list *, int, int *,

char *, size_t, freelist_t *);

static const char *converttuple(PyObject *, const char **, va_list *, int,

int *, char *, size_t, int, freelist_t *);

static const char *convertsimple(PyObject *, const char **, va_list *, int,

char *, size_t, freelist_t *);

static Py_ssize_t convertbuffer(PyObject *, const void **p, const char **);

static int getbuffer(PyObject *, Py_buffer *, const char**);

static int vgetargskeywords(PyObject *, PyObject *,

const char *, char **, va_list *, int);

static int vgetargskeywordsfast(PyObject *, PyObject *,

struct _PyArg_Parser *, va_list *, int);

static int vgetargskeywordsfast_impl(PyObject *const *args, Py_ssize_t nargs,

PyObject *keywords, PyObject *kwnames,

struct _PyArg_Parser *parser,

va_list *p_va, int flags);

static const char *skipitem(const char **, va_list *, int);

int

PyArg_Parse(PyObject *args, const char *format, ...)

{

int retval;

va_list va;

va_start(va, format);

retval = vgetargs1(args, format, &va, FLAG_COMPAT);

va_end(va);

return retval;

}

int

_PyArg_Parse_SizeT(PyObject *args, const char *format, ...)

{

int retval;

va_list va;

va_start(va, format);

retval = vgetargs1(args, format, &va, FLAG_COMPAT|FLAG_SIZE_T);

va_end(va);

return retval;

}

int

PyArg_ParseTuple(PyObject *args, const char *format, ...)

{

int retval;

va_list va;

va_start(va, format);

retval = vgetargs1(args, format, &va, 0);

va_end(va);

return retval;

}

int

_PyArg_ParseTuple_SizeT(PyObject *args, const char *format, ...)

{

int retval;

va_list va;

va_start(va, format);

retval = vgetargs1(args, format, &va, FLAG_SIZE_T);

va_end(va);

return retval;

}

int

_PyArg_ParseStack(PyObject *const *args, Py_ssize_t nargs, const char *format, ...)

{

int retval;

va_list va;

va_start(va, format);

retval = vgetargs1_impl(NULL, args, nargs, format, &va, 0);

va_end(va);

return retval;

}

int

_PyArg_ParseStack_SizeT(PyObject *const *args, Py_ssize_t nargs, const char *format, ...)

{

int retval;

va_list va;

va_start(va, format);

retval = vgetargs1_impl(NULL, args, nargs, format, &va, FLAG_SIZE_T);

va_end(va);

return retval;

}

int

PyArg_VaParse(PyObject *args, const char *format, va_list va)

{

va_list lva;

int retval;

va_copy(lva, va);

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

va_end(lva);

return retval;

}

int

_PyArg_VaParse_SizeT(PyObject *args, const char *format, va_list va)

{

va_list lva;

int retval;

va_copy(lva, va);

retval = vgetargs1(args, format, &lva, FLAG_SIZE_T);

va_end(lva);

return retval;

}

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

static int

cleanup_ptr(PyObject *self, void *ptr)

{

if (ptr) {

PyMem_FREE(ptr);

}

return 0;

}

static int

cleanup_buffer(PyObject *self, void *ptr)

{

Py_buffer *buf = (Py_buffer *)ptr;

if (buf) {

PyBuffer_Release(buf);

}

return 0;

}

static int

addcleanup(void *ptr, freelist_t *freelist, destr_t destructor)

{

int index;

index = freelist->first_available;

freelist->first_available += 1;

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

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

return 0;

}

static int

cleanreturn(int retval, freelist_t *freelist)

{

int index;

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);

return retval;

}

static int

vgetargs1_impl(PyObject *compat_args, PyObject *const *stack, Py_ssize_t nargs, const char *format,

va_list *p_va, int flags)

{

char msgbuf[256];

int levels[32];

const char *fname = NULL;

const char *message = NULL;

int min = -1;

int max = 0;

int level = 0;

int endfmt = 0;

const char *formatsave = format;

Py_ssize_t i;

const char *msg;

int compat = flags & FLAG_COMPAT;

freelistentry_t static_entries[STATIC_FREELIST_ENTRIES];

freelist_t freelist;

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

freelist.entries = static_entries;

freelist.first_available = 0;

freelist.entries_malloced = 0;

flags = flags & ~FLAG_COMPAT;

while (endfmt == 0) {

int c = *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(Py_CHARMASK(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();

return 0;

}

freelist.entries_malloced = 1;

}

if (compat) {

if (max == 0) {

if (compat_args == NULL)

return 1;

PyErr_Format(PyExc_TypeError,

"%.200s%s takes no arguments",

fname==NULL ? "function" : fname,

fname==NULL ? "" : "()");

return cleanreturn(0, &freelist);

}

else if (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 ? "" : "()");

return cleanreturn(0, &freelist);

}

msg = convertitem(compat_args, &format, p_va, flags, levels,

msgbuf, sizeof(msgbuf), &freelist);

if (msg == NULL)

return cleanreturn(1, &freelist);

seterror(levels[0], msg, levels+1, fname, message);

return cleanreturn(0, &freelist);

}

else {

PyErr_SetString(PyExc_SystemError,

"old style getargs format uses new features");

return cleanreturn(0, &freelist);

}

}

if (nargs < min || max < nargs) {

if (message == NULL)

PyErr_Format(PyExc_TypeError,

"%.150s%s takes %s %d argument%s (%ld 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",

Py_SAFE_DOWNCAST(nargs, Py_ssize_t, long));

else

PyErr_SetString(PyExc_TypeError, message);

return cleanreturn(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);

return cleanreturn(0, &freelist);

}

}

if (*format != '\0' && !Py_ISALPHA(Py_CHARMASK(*format)) &&

*format != '(' &&

*format != '|' && *format != ':' && *format != ';') {

PyErr_Format(PyExc_SystemError,

"bad format string: %.200s", formatsave);

return cleanreturn(0, &freelist);

}

return cleanreturn(1, &freelist);

}

static int

vgetargs1(PyObject *args, const char *format, va_list *p_va, int flags)

{

PyObject **stack;

Py_ssize_t nargs;

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");

return 0;

}

stack = _PyTuple_ITEMS(args);

nargs = PyTuple_GET_SIZE(args);

}

else {

stack = NULL;

nargs = 0;

}

return vgetargs1_impl(args, stack, nargs, format, p_va, flags);

}

static void

seterror(Py_ssize_t iarg, const char *msg, int *levels, const char *fname,

const char *message)

{

char buf[512];

int i;

char *p = buf;

if (PyErr_Occurred())

return;

else if (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 %" PY_FORMAT_SIZE_T "d", 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.

*/

static const char *

converttuple(PyObject *arg, const char **p_format, va_list *p_va, int flags,

int *levels, char *msgbuf, size_t bufsize, int toplevel,

freelist_t *freelist)

{

int level = 0;

int n = 0;

const char *format = *p_format;

int i;

Py_ssize_t len;

for (;;) {

int c = *format++;

if (c == '(') {

if (level == 0)

n++;

level++;

}

else if (c == ')') {

if (level == 0)

break;

level--;

}

else if (c == ':' || c == ';' || c == '\0')

break;

else if (level == 0 && Py_ISALPHA(Py_CHARMASK(c)))

n++;

}

if (!PySequence_Check(arg) || PyBytes_Check(arg)) {

levels[0] = 0;

PyOS_snprintf(msgbuf, bufsize,

toplevel ? "expected %d arguments, not %.50s" :

"must be %d-item sequence, not %.50s",

n,

arg == Py_None ? "None" : arg->ob_type->tp_name);

return msgbuf;

}

len = PySequence_Size(arg);

if (len != n) {

levels[0] = 0;

if (toplevel) {

PyOS_snprintf(msgbuf, bufsize,

"expected %d argument%s, not %" PY_FORMAT_SIZE_T "d",

n,

n == 1 ? "" : "s",

len);

}

else {

PyOS_snprintf(msgbuf, bufsize,

"must be sequence of length %d, "

"not %" PY_FORMAT_SIZE_T "d",

n, len);

}

return msgbuf;

}

format = *p_format;

for (i = 0; i < n; i++) {

const char *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);

return msgbuf;

}

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;

return msg;

}

}

*p_format = format;

return NULL;

}

/* Convert a single item. */

static const char *

convertitem(PyObject *arg, const char **p_format, va_list *p_va, int flags,

int *levels, char *msgbuf, size_t bufsize, freelist_t *freelist)

{

const char *msg;

const char *format = *p_format;

if (*format == '(' /* ')' */) {

format++;

msg = converttuple(arg, &format, p_va, flags, levels, msgbuf,

bufsize, 0, 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;

return msg;

}

/* Format an error message generated by convertsimple(). */

static const char *

converterr(const char *expected, PyObject *arg, char *msgbuf, size_t bufsize)

{

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" : arg->ob_type->tp_name);

}

return msgbuf;

}

#define CONV_UNICODE "(unicode conversion error)"

/* Explicitly check for float arguments when integers are expected.

Return 1 for error, 0 if ok. */

static int

float_argument_error(PyObject *arg)

{

if (PyFloat_Check(arg)) {

PyErr_SetString(PyExc_TypeError,

"integer argument expected, got float" );

return 1;

}

else

return 0;

}

/* 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.

*/

static const char *

convertsimple(PyObject *arg, const char **p_format, va_list *p_va, int flags,

char *msgbuf, size_t bufsize, freelist_t *freelist)

{

/* For # codes */

#define FETCH_SIZE int *q=NULL;Py_ssize_t *q2=NULL;\

if (flags & FLAG_SIZE_T) q2=va_arg(*p_va, Py_ssize_t*); \

else q=va_arg(*p_va, int*);

#define STORE_SIZE(s) \

if (flags & FLAG_SIZE_T) \

*q2=s; \

else { \

if (INT_MAX < s) { \

PyErr_SetString(PyExc_OverflowError, \

"size does not fit in an int"); \

return converterr("", arg, msgbuf, bufsize); \

} \

*q = (int)s; \

}

#define BUFFER_LEN ((flags & FLAG_SIZE_T) ? *q2:*q)

#define RETURN_ERR_OCCURRED return msgbuf

const char *format = *p_format;

char c = *format++;

const char *sarg;

switch (c) {

case 'b': { /* unsigned byte -- very short int */

char *p = va_arg(*p_va, char *);

long ival;

if (float_argument_error(arg))

RETURN_ERR_OCCURRED;

ival = PyLong_AsLong(arg);

if (ival == -1 && PyErr_Occurred())

RETURN_ERR_OCCURRED;

else if (ival < 0) {

PyErr_SetString(PyExc_OverflowError,

"unsigned byte integer is less than minimum");

RETURN_ERR_OCCURRED;

}

else if (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 */

char *p = va_arg(*p_va, char *);

long ival;

if (float_argument_error(arg))

RETURN_ERR_OCCURRED;

ival = PyLong_AsUnsignedLongMask(arg);

if (ival == -1 && PyErr_Occurred())

RETURN_ERR_OCCURRED;

else

*p = (unsigned char) ival;

break;

}

case 'h': {/* signed short int */

short *p = va_arg(*p_va, short *);

long ival;

if (float_argument_error(arg))

RETURN_ERR_OCCURRED;

ival = PyLong_AsLong(arg);

if (ival == -1 && PyErr_Occurred())

RETURN_ERR_OCCURRED;

else if (ival < SHRT_MIN) {

PyErr_SetString(PyExc_OverflowError,

"signed short integer is less than minimum");

RETURN_ERR_OCCURRED;

}

else if (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, unsigned short *);

long ival;

if (float_argument_error(arg))

RETURN_ERR_OCCURRED;

ival = PyLong_AsUnsignedLongMask(arg);

if (ival == -1 && PyErr_Occurred())

RETURN_ERR_OCCURRED;

else

*p = (unsigned short) ival;

break;

}

case 'i': {/* signed int */

int *p = va_arg(*p_va, int *);

long ival;

if (float_argument_error(arg))

RETURN_ERR_OCCURRED;

ival = PyLong_AsLong(arg);

if (ival == -1 && PyErr_Occurred())

RETURN_ERR_OCCURRED;

else if (ival > INT_MAX) {

PyErr_SetString(PyExc_OverflowError,

"signed integer is greater than maximum");

RETURN_ERR_OCCURRED;

}

else if (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, unsigned int *);

unsigned int ival;

if (float_argument_error(arg))

RETURN_ERR_OCCURRED;

ival = (unsigned int)PyLong_AsUnsignedLongMask(arg);

if (ival == (unsigned int)-1 && PyErr_Occurred())

RETURN_ERR_OCCURRED;

else

*p = ival;

break;

}

case 'n': /* Py_ssize_t */

{

PyObject *iobj;

Py_ssize_t *p = va_arg(*p_va, Py_ssize_t *);

Py_ssize_t ival = -1;

if (float_argument_error(arg))

RETURN_ERR_OCCURRED;

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 *);

long ival;

if (float_argument_error(arg))

RETURN_ERR_OCCURRED;

ival = 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, unsigned long *);

unsigned long ival;

if (PyLong_Check(arg))

ival = PyLong_AsUnsignedLongMask(arg);

else

return converterr("int", arg, msgbuf, bufsize);

*p = ival;

break;

}

case 'L': {/* long long */

long long *p = va_arg( *p_va, long long * );

long long ival;

if (float_argument_error(arg))

RETURN_ERR_OCCURRED;

ival = 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, unsigned long long *);

unsigned long long ival;

if (PyLong_Check(arg))

ival = PyLong_AsUnsignedLongLongMask(arg);

else

return converterr("int", arg, msgbuf, bufsize);

*p = ival;

break;

}

case 'f': {/* float */

float *p = va_arg(*p_va, float *);

double dval = PyFloat_AsDouble(arg);

if (PyErr_Occurred())

RETURN_ERR_OCCURRED;

else

*p = (float) dval;

break;

}

case 'd': {/* double */

double *p = va_arg(*p_va, double *);

double dval = PyFloat_AsDouble(arg);

if (PyErr_Occurred())

RETURN_ERR_OCCURRED;

else

*p = dval;

break;

}

case 'D': {/* complex double */

Py_complex *p = va_arg(*p_va, Py_complex *);

Py_complex cval;

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];

else if (PyByteArray_Check(arg) && PyByteArray_Size(arg) == 1)

*p = PyByteArray_AS_STRING(arg)[0];

else

return converterr("a byte string of length 1", arg, msgbuf, bufsize);

break;

}

case 'C': {/* unicode char */

int *p = va_arg(*p_va, int *);

int kind;

void *data;

if (!PyUnicode_Check(arg))

return converterr("a unicode character", arg, msgbuf, bufsize);

if (PyUnicode_READY(arg))

RETURN_ERR_OCCURRED;

if (PyUnicode_GET_LENGTH(arg) != 1)

return converterr("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 *);

int val = PyObject_IsTrue(arg);

if (val > 0)

*p = 1;

else if (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 **);

const char *buf;

Py_ssize_t count;

if (*format == '*') {

if (getbuffer(arg, (Py_buffer*)p, &buf) < 0)

return converterr(buf, arg, msgbuf, bufsize);

format++;

if (addcleanup(p, freelist, cleanup_buffer)) {

return converterr(

"(cleanup problem)",

arg, msgbuf, bufsize);

}

break;

}

count = convertbuffer(arg, (const void **)p, &buf);

if (count < 0)

return converterr(buf, arg, msgbuf, bufsize);

if (*format == '#') {

FETCH_SIZE;

STORE_SIZE(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);

else if (PyUnicode_Check(arg)) {

Py_ssize_t len;

sarg = PyUnicode_AsUTF8AndSize(arg, &len);

if (sarg == NULL)

return converterr(CONV_UNICODE,

arg, msgbuf, bufsize);

PyBuffer_FillInfo(p, arg, (void *)sarg, len, 1, 0);

}

else { /* any bytes-like object */

const char *buf;

if (getbuffer(arg, p, &buf) < 0)

return converterr(buf, arg, msgbuf, bufsize);

}

if (addcleanup(p, freelist, cleanup_buffer)) {

return converterr(

"(cleanup problem)",

arg, msgbuf, bufsize);

}

format++;

} else if (*format == '#') { /* a string or read-only bytes-like object */

/* "s#" or "z#" */

const void **p = (const void **)va_arg(*p_va, const char **);

FETCH_SIZE;