/* New getargs implementation */

#include "Python.h"

#include <ctype.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);

#ifdef HAVE_DECLSPEC_DLL

/* Export functions */

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

PyAPI_FUNC(int) _PyArg_ParseTuple_SizeT(PyObject *, 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 *, char *, va_list);

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

const char *, char **, va_list);

#endif

#define FLAG_COMPAT 1

#define FLAG_SIZE_T 2

/* Forward */

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

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

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

char *, size_t, PyObject **);

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

int *, char *, size_t, int, PyObject **);

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

size_t, PyObject **);

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

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

static int vgetargskeywords(PyObject *, PyObject *,

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

static 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, 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, 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_VaParse(PyObject *args, const char *format, va_list va)

{

va_list lva;

Py_VA_COPY(lva, va);

return vgetargs1(args, format, &lva, 0);

}

int

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

{

va_list lva;

Py_VA_COPY(lva, va);

return vgetargs1(args, format, &lva, FLAG_SIZE_T);

}

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

#define GETARGS_CAPSULE_NAME_CLEANUP_PTR "getargs.cleanup_ptr"

#define GETARGS_CAPSULE_NAME_CLEANUP_BUFFER "getargs.cleanup_buffer"

#define GETARGS_CAPSULE_NAME_CLEANUP_CONVERT "getargs.cleanup_convert"

static void

cleanup_ptr(PyObject *self)

{

void *ptr = PyCapsule_GetPointer(self, GETARGS_CAPSULE_NAME_CLEANUP_PTR);

if (ptr) {

PyMem_FREE(ptr);

}

}

static void

cleanup_buffer(PyObject *self)

{

Py_buffer *ptr = (Py_buffer *)PyCapsule_GetPointer(self, GETARGS_CAPSULE_NAME_CLEANUP_BUFFER);

if (ptr) {

PyBuffer_Release(ptr);

}

}

static int

addcleanup(void *ptr, PyObject **freelist, PyCapsule_Destructor destr)

{

PyObject *cobj;

const char *name;

if (!*freelist) {

*freelist = PyList_New(0);

if (!*freelist) {

destr(ptr);

return -1;

}

}

if (destr == cleanup_ptr) {

name = GETARGS_CAPSULE_NAME_CLEANUP_PTR;

} else if (destr == cleanup_buffer) {

name = GETARGS_CAPSULE_NAME_CLEANUP_BUFFER;

} else {

return -1;

}

cobj = PyCapsule_New(ptr, name, destr);

if (!cobj) {

destr(ptr);

return -1;

}

if (PyList_Append(*freelist, cobj)) {

Py_DECREF(cobj);

return -1;

}

Py_DECREF(cobj);

return 0;

}

static void

cleanup_convert(PyObject *self)

{

typedef int (*destr_t)(PyObject *, void *);

destr_t destr = (destr_t)PyCapsule_GetContext(self);

void *ptr = PyCapsule_GetPointer(self,

GETARGS_CAPSULE_NAME_CLEANUP_CONVERT);

if (ptr && destr)

destr(NULL, ptr);

}

static int

addcleanup_convert(void *ptr, PyObject **freelist, int (*destr)(PyObject*,void*))

{

PyObject *cobj;

if (!*freelist) {

*freelist = PyList_New(0);

if (!*freelist) {

destr(NULL, ptr);

return -1;

}

}

cobj = PyCapsule_New(ptr, GETARGS_CAPSULE_NAME_CLEANUP_CONVERT,

cleanup_convert);

if (!cobj) {

destr(NULL, ptr);

return -1;

}

if (PyCapsule_SetContext(cobj, destr) == -1) {

/* This really should not happen. */

Py_FatalError("capsule refused setting of context.");

}

if (PyList_Append(*freelist, cobj)) {

Py_DECREF(cobj); /* This will also call destr. */

return -1;

}

Py_DECREF(cobj);

return 0;

}

static int

cleanreturn(int retval, PyObject *freelist)

{

if (freelist && retval != 0) {

/* We were successful, reset the destructors so that they

don't get called. */

Py_ssize_t len = PyList_GET_SIZE(freelist), i;

for (i = 0; i < len; i++)

PyCapsule_SetDestructor(PyList_GET_ITEM(freelist, i), NULL);

}

Py_XDECREF(freelist);

return retval;

}

static int

vgetargs1(PyObject *args, 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, len;

char *msg;

PyObject *freelist = NULL;

int compat = flags & FLAG_COMPAT;

assert(compat || (args != (PyObject*)NULL));

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;

default:

if (level == 0) {

if (c == 'O')

max++;

else if (isalpha(Py_CHARMASK(c))) {

if (c != 'e') /* skip encoded */

max++;

} else if (c == '|')

min = max;

}

break;

}

}

if (level != 0)

Py_FatalError(/* '(' */ "missing ')' in getargs format");

if (min < 0)

min = max;

format = formatsave;

if (compat) {

if (max == 0) {

if (args == NULL)

return 1;

PyOS_snprintf(msgbuf, sizeof(msgbuf),

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

fname==NULL ? "function" : fname,

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

PyErr_SetString(PyExc_TypeError, msgbuf);

return 0;

}

else if (min == 1 && max == 1) {

if (args == NULL) {

PyOS_snprintf(msgbuf, sizeof(msgbuf),

"%.200s%s takes at least one argument",

fname==NULL ? "function" : fname,

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

PyErr_SetString(PyExc_TypeError, msgbuf);

return 0;

}

msg = convertitem(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 0;

}

}

if (!PyTuple_Check(args)) {

PyErr_SetString(PyExc_SystemError,

"new style getargs format but argument is not a tuple");

return 0;

}

len = PyTuple_GET_SIZE(args);

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

if (message == NULL) {

PyOS_snprintf(msgbuf, sizeof(msgbuf),

"%.150s%s takes %s %d argument%s "

"(%ld given)",

fname==NULL ? "function" : fname,

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

min==max ? "exactly"

: len < min ? "at least" : "at most",

len < min ? min : max,

(len < min ? min : max) == 1 ? "" : "s",

Py_SAFE_DOWNCAST(len, Py_ssize_t, long));

message = msgbuf;

}

PyErr_SetString(PyExc_TypeError, message);

return 0;

}

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

if (*format == '|')

format++;

msg = convertitem(PyTuple_GET_ITEM(args, i), &format, p_va,

flags, levels, msgbuf,

sizeof(msgbuf), &freelist);

if (msg) {

seterror(i+1, msg, levels, fname, msg);

return cleanreturn(0, freelist);

}

}

if (*format != '\0' && !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 void

seterror(int 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 %d", iarg);

i = 0;

p += strlen(p);

while (levels[i] > 0 && i < 32 && (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;

}

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 char *

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

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

PyObject **freelist)

{

int level = 0;

int n = 0;

const char *format = *p_format;

int i;

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

}

if ((i = PySequence_Size(arg)) != n) {

levels[0] = 0;

PyOS_snprintf(msgbuf, bufsize,

toplevel ? "expected %d arguments, not %d" :

"must be sequence of length %d, not %d",

n, i);

return msgbuf;

}

format = *p_format;

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

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 char *

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

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

{

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;

}

#define UNICODE_DEFAULT_ENCODING(arg) \

_PyUnicode_AsDefaultEncodedString(arg, NULL)

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

static char *

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

{

assert(expected != NULL);

assert(arg != NULL);

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 char *

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

char *msgbuf, size_t bufsize, PyObject **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=s; \

}

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

const char *format = *p_format;

char c = *format++;

PyObject *uarg;

switch (c) {

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

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

long ival;

if (float_argument_error(arg))

return converterr("integer<b>", arg, msgbuf, bufsize);

ival = PyLong_AsLong(arg);

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

return converterr("integer<b>", arg, msgbuf, bufsize);

else if (ival < 0) {

PyErr_SetString(PyExc_OverflowError,

"unsigned byte integer is less than minimum");

return converterr("integer<b>", arg, msgbuf, bufsize);

}

else if (ival > UCHAR_MAX) {

PyErr_SetString(PyExc_OverflowError,

"unsigned byte integer is greater than maximum");

return converterr("integer<b>", arg, msgbuf, bufsize);

}

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 converterr("integer<B>", arg, msgbuf, bufsize);

ival = PyLong_AsUnsignedLongMask(arg);

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

return converterr("integer<B>", arg, msgbuf, bufsize);

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 converterr("integer<h>", arg, msgbuf, bufsize);

ival = PyLong_AsLong(arg);

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

return converterr("integer<h>", arg, msgbuf, bufsize);

else if (ival < SHRT_MIN) {

PyErr_SetString(PyExc_OverflowError,

"signed short integer is less than minimum");

return converterr("integer<h>", arg, msgbuf, bufsize);

}

else if (ival > SHRT_MAX) {

PyErr_SetString(PyExc_OverflowError,

"signed short integer is greater than maximum");

return converterr("integer<h>", arg, msgbuf, bufsize);

}

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 converterr("integer<H>", arg, msgbuf, bufsize);

ival = PyLong_AsUnsignedLongMask(arg);

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

return converterr("integer<H>", arg, msgbuf, bufsize);

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 converterr("integer<i>", arg, msgbuf, bufsize);

ival = PyLong_AsLong(arg);

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

return converterr("integer<i>", arg, msgbuf, bufsize);

else if (ival > INT_MAX) {

PyErr_SetString(PyExc_OverflowError,

"signed integer is greater than maximum");

return converterr("integer<i>", arg, msgbuf, bufsize);

}

else if (ival < INT_MIN) {

PyErr_SetString(PyExc_OverflowError,

"signed integer is less than minimum");

return converterr("integer<i>", arg, msgbuf, bufsize);

}

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 converterr("integer<I>", arg, msgbuf, bufsize);

ival = (unsigned int)PyLong_AsUnsignedLongMask(arg);

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

return converterr("integer<I>", arg, msgbuf, bufsize);

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 converterr("integer<n>", arg, msgbuf, bufsize);

iobj = PyNumber_Index(arg);

if (iobj != NULL) {

ival = PyLong_AsSsize_t(iobj);

Py_DECREF(iobj);

}

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

return converterr("integer<n>", arg, msgbuf, bufsize);

*p = ival;

break;

}

case 'l': {/* long int */

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

long ival;

if (float_argument_error(arg))

return converterr("integer<l>", arg, msgbuf, bufsize);

ival = PyLong_AsLong(arg);

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

return converterr("integer<l>", arg, msgbuf, bufsize);

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("integer<k>", arg, msgbuf, bufsize);

*p = ival;

break;

}

#ifdef HAVE_LONG_LONG

case 'L': {/* PY_LONG_LONG */

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

PY_LONG_LONG ival;

if (float_argument_error(arg))

return converterr("long<L>", arg, msgbuf, bufsize);

ival = PyLong_AsLongLong(arg);

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

return converterr("long<L>", arg, msgbuf, bufsize);

else

*p = ival;

break;

}

case 'K': { /* long long sized bitfield */

unsigned PY_LONG_LONG *p = va_arg(*p_va, unsigned PY_LONG_LONG *);

unsigned PY_LONG_LONG ival;

if (PyLong_Check(arg))

ival = PyLong_AsUnsignedLongLongMask(arg);

else

return converterr("integer<K>", arg, msgbuf, bufsize);

*p = ival;

break;

}

#endif

case 'f': {/* float */

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

double dval = PyFloat_AsDouble(arg);

if (PyErr_Occurred())

return converterr("float<f>", arg, msgbuf, bufsize);

else

*p = (float) dval;

break;

}

case 'd': {/* double */

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

double dval = PyFloat_AsDouble(arg);

if (PyErr_Occurred())

return converterr("float<d>", arg, msgbuf, bufsize);

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 converterr("complex<D>", arg, msgbuf, bufsize);

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

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

break;

}

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

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

if (PyUnicode_Check(arg) &&

PyUnicode_GET_SIZE(arg) == 1)

*p = PyUnicode_AS_UNICODE(arg)[0];

else

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

break;

}

/* XXX WAAAAH! 's', 'y', 'z', 'u', 'Z', 'e', 'w' codes all

need to be cleaned up! */

case 'y': {/* any buffer-like object, but not PyUnicode */

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

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, p, &buf);

if (count < 0)

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

if (*format == '#') {

FETCH_SIZE;

STORE_SIZE(count);

format++;

} else {

if (strlen(*p) != count)

return converterr(

"bytes without null bytes",

arg, msgbuf, bufsize);

}

break;

}

case 's': /* text string */

case 'z': /* text string 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)) {

uarg = UNICODE_DEFAULT_ENCODING(arg);

if (uarg == NULL)

return converterr(CONV_UNICODE,

arg, msgbuf, bufsize);

PyBuffer_FillInfo(p, arg,

PyBytes_AS_STRING(uarg), PyBytes_GET_SIZE(uarg),

1, 0);

}

else { /* any buffer-like object */

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 == '#') { /* any buffer-like object */

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

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

FETCH_SIZE;

if (c == 'z' && arg == Py_None) {

*p = NULL;

STORE_SIZE(0);

}

else if (PyUnicode_Check(arg)) {

uarg = UNICODE_DEFAULT_ENCODING(arg);

if (uarg == NULL)

return converterr(CONV_UNICODE,

arg, msgbuf, bufsize);

*p = PyBytes_AS_STRING(uarg);

STORE_SIZE(PyBytes_GET_SIZE(uarg));

}

else { /* any buffer-like object */

/* XXX Really? */

char *buf;

Py_ssize_t count = convertbuffer(arg, p, &buf);

if (count < 0)

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

STORE_SIZE(count);

}

format++;

} else {

/* "s" or "z" */

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

uarg = NULL;

if (c == 'z' && arg == Py_None)

*p = NULL;

else if (PyUnicode_Check(arg)) {

uarg = UNICODE_DEFAULT_ENCODING(arg);

if (uarg == NULL)

return converterr(CONV_UNICODE,

arg, msgbuf, bufsize);

*p = PyBytes_AS_STRING(uarg);

}

else

return converterr(c == 'z' ? "str or None" : "str",

arg, msgbuf, bufsize);

if (*p != NULL && uarg != NULL &&

(Py_ssize_t) strlen(*p) != PyBytes_GET_SIZE(uarg))

return converterr(

c == 'z' ? "str without null bytes or None"

: "str without null bytes",

arg, msgbuf, bufsize);

}

break;

}

case 'u': /* raw unicode buffer (Py_UNICODE *) */

case 'Z': /* raw unicode buffer or None */

{

if (*format == '#') { /* any buffer-like object */

/* "s#" or "Z#" */

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

FETCH_SIZE;

if (c == 'Z' && arg == Py_None) {

*p = NULL;

STORE_SIZE(0);

}

else if (PyUnicode_Check(arg)) {

*p = PyUnicode_AS_UNICODE(arg);

STORE_SIZE(PyUnicode_GET_SIZE(arg));

}

else

return converterr("str or None", arg, msgbuf, bufsize);

format++;

} else {

/* "s" or "Z" */

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

if (c == 'Z' && arg == Py_None)

*p = NULL;

else if (PyUnicode_Check(arg)) {

*p = PyUnicode_AS_UNICODE(arg);

if (Py_UNICODE_strlen(*p) != PyUnicode_GET_SIZE(arg))

return converterr(

"str without null character or None",

arg, msgbuf, bufsize);

} else

return converterr(c == 'Z' ? "str or None" : "str",

arg, msgbuf, bufsize);

}

break;

}