1 

     2 /* New getargs implementation */

     3 

     4 #include "Python.h"

     5 

     6 #include <ctype.h>

     7 

     8 

     9 #ifdef __cplusplus

    10 extern "C" { 

    11 #endif

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

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

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

    15 

    16 int PyArg_ParseTupleAndKeywords(PyObject *, PyObject *,

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

    18 int PyArg_VaParseTupleAndKeywords(PyObject *, PyObject *,

    19 				const char *, char **, va_list);

    20 

    21 #ifdef HAVE_DECLSPEC_DLL

    22 /* Export functions */

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

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

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

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

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

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

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

    30                                               const char *, char **, va_list);

    31 #endif

    32 

    33 #define FLAG_COMPAT 1

    34 #define FLAG_SIZE_T 2

    35 

    36 

    37 /* Forward */

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

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

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

    41                          char *, size_t, PyObject **);

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

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

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

    45 			   size_t, PyObject **);

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

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

    48 

    49 static int vgetargskeywords(PyObject *, PyObject *,

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

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

    52 

    53 int

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

    55 {

    56 	int retval;

    57 	va_list va;

    58 	

    59 	va_start(va, format);

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

    61 	va_end(va);

    62 	return retval;

    63 }

    64 

    65 int

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

    67 {

    68 	int retval;

    69 	va_list va;

    70 	

    71 	va_start(va, format);

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

    73 	va_end(va);

    74 	return retval;

    75 }

    76 

    77 

    78 int

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

    80 {

    81 	int retval;

    82 	va_list va;

    83 	

    84 	va_start(va, format);

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

    86 	va_end(va);

    87 	return retval;

    88 }

    89 

    90 int

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

    92 {

    93 	int retval;

    94 	va_list va;

    95 	

    96 	va_start(va, format);

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

    98 	va_end(va);

    99 	return retval;

   100 }

   101 

   102 

   103 int

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

   105 {

   106 	va_list lva;

   107 

   108 #ifdef VA_LIST_IS_ARRAY

   109 	memcpy(lva, va, sizeof(va_list));

   110 #else

   111 #ifdef __va_copy

   112 	__va_copy(lva, va);

   113 #else

   114 	lva = va;

   115 #endif

   116 #endif

   117 

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

   119 }

   120 

   121 int

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

   123 {

   124 	va_list lva;

   125 

   126 #ifdef VA_LIST_IS_ARRAY

   127 	memcpy(lva, va, sizeof(va_list));

   128 #else

   129 #ifdef __va_copy

   130 	__va_copy(lva, va);

   131 #else

   132 	lva = va;

   133 #endif

   134 #endif

   135 

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

   137 }

   138 

   139 

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

   141 

   142 static void

   143 cleanup_ptr(void *ptr)

   144 {

   145 	PyMem_FREE(ptr);

   146 }

   147 

   148 static void

   149 cleanup_buffer(void *ptr)

   150 {

   151 	PyBuffer_Release((Py_buffer *) ptr);

   152 }

   153 

   154 static int

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

   156 {

   157 	PyObject *cobj;

   158 	if (!*freelist) {

   159 		*freelist = PyList_New(0);

   160 		if (!*freelist) {

   161 			destr(ptr);

   162 			return -1;

   163 		}

   164 	}

   165 	cobj = PyCObject_FromVoidPtr(ptr, destr);

   166 	if (!cobj) {

   167 		destr(ptr);

   168 		return -1;

   169 	}

   170 	if (PyList_Append(*freelist, cobj)) {

   171 		Py_DECREF(cobj);

   172 		return -1;

   173 	}

   174         Py_DECREF(cobj);

   175 	return 0;

   176 }

   177 

   178 static int

   179 cleanreturn(int retval, PyObject *freelist)

   180 {

   181 	if (freelist && retval != 0) {

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

   183 		   don't get called. */

   184 		Py_ssize_t len = PyList_GET_SIZE(freelist), i;

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

   186 			((PyCObject *) PyList_GET_ITEM(freelist, i))

   187 				->destructor = NULL;

   188 	}

   189 	Py_XDECREF(freelist);

   190 	return retval;

   191 }

   192 

   193 

   194 static int

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

   196 {

   197 	char msgbuf[256];

   198 	int levels[32];

   199 	const char *fname = NULL;

   200 	const char *message = NULL;

   201 	int min = -1;

   202 	int max = 0;

   203 	int level = 0;

   204 	int endfmt = 0;

   205 	const char *formatsave = format;

   206 	Py_ssize_t i, len;

   207 	char *msg;

   208 	PyObject *freelist = NULL;

   209 	int compat = flags & FLAG_COMPAT;

   210 

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

   212 	flags = flags & ~FLAG_COMPAT;

   213 

   214 	while (endfmt == 0) {

   215 		int c = *format++;

   216 		switch (c) {

   217 		case '(':

   218 			if (level == 0)

   219 				max++;

   220 			level++;

   221 			if (level >= 30)

   222 				Py_FatalError("too many tuple nesting levels "

   223 					      "in argument format string");

   224 			break;

   225 		case ')':

   226 			if (level == 0)

   227 				Py_FatalError("excess ')' in getargs format");

   228 			else

   229 				level--;

   230 			break;

   231 		case '\0':

   232 			endfmt = 1;

   233 			break;

   234 		case ':':

   235 			fname = format;

   236 			endfmt = 1;

   237 			break;

   238 		case ';':

   239 			message = format;

   240 			endfmt = 1;

   241 			break;

   242 		default:

   243 			if (level == 0) {

   244 				if (c == 'O')

   245 					max++;

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

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

   248 						max++;

   249 				} else if (c == '|')

   250 					min = max;

   251 			}

   252 			break;

   253 		}

   254 	}

   255 	

   256 	if (level != 0)

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

   258 	

   259 	if (min < 0)

   260 		min = max;

   261 	

   262 	format = formatsave;

   263 	

   264 	if (compat) {

   265 		if (max == 0) {

   266 			if (args == NULL)

   267 				return 1;

   268 			PyOS_snprintf(msgbuf, sizeof(msgbuf),

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

   270 				      fname==NULL ? "function" : fname,

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

   272 			PyErr_SetString(PyExc_TypeError, msgbuf);

   273 			return 0;

   274 		}

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

   276 			if (args == NULL) {

   277 				PyOS_snprintf(msgbuf, sizeof(msgbuf),

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

   279 					      fname==NULL ? "function" : fname,

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

   281 				PyErr_SetString(PyExc_TypeError, msgbuf);

   282 				return 0;

   283 			}

   284 			msg = convertitem(args, &format, p_va, flags, levels, 

   285 					  msgbuf, sizeof(msgbuf), &freelist);

   286 			if (msg == NULL)

   287 				return cleanreturn(1, freelist);

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

   289 			return cleanreturn(0, freelist);

   290 		}

   291 		else {

   292 			PyErr_SetString(PyExc_SystemError,

   293 			    "old style getargs format uses new features");

   294 			return 0;

   295 		}

   296 	}

   297 	

   298 	if (!PyTuple_Check(args)) {

   299 		PyErr_SetString(PyExc_SystemError,

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

   301 		return 0;

   302 	}

   303 	

   304 	len = PyTuple_GET_SIZE(args);

   305 	

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

   307 		if (message == NULL) {

   308 			PyOS_snprintf(msgbuf, sizeof(msgbuf),

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

   310 				      "(%ld given)",

   311 				      fname==NULL ? "function" : fname,

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

   313 				      min==max ? "exactly"

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

   315 				      len < min ? min : max,

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

   317 				      Py_SAFE_DOWNCAST(len, Py_ssize_t, long));

   318 			message = msgbuf;

   319 		}

   320 		PyErr_SetString(PyExc_TypeError, message);

   321 		return 0;

   322 	}

   323 	

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

   325 		if (*format == '|')

   326 			format++;

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

   328 				  flags, levels, msgbuf, 

   329 				  sizeof(msgbuf), &freelist);

   330 		if (msg) {

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

   332 			return cleanreturn(0, freelist);

   333 		}

   334 	}

   335 

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

   337 	    *format != '(' &&

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

   339 		PyErr_Format(PyExc_SystemError,

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

   341 		return cleanreturn(0, freelist);

   342 	}

   343 	

   344 	return cleanreturn(1, freelist);

   345 }

   346 

   347 

   348 

   349 static void

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

   351          const char *message)

   352 {

   353 	char buf[512];

   354 	int i;

   355 	char *p = buf;

   356 

   357 	if (PyErr_Occurred())

   358 		return;

   359 	else if (message == NULL) {

   360 		if (fname != NULL) {

   361 			PyOS_snprintf(p, sizeof(buf), "%.200s() ", fname);

   362 			p += strlen(p);

   363 		}

   364 		if (iarg != 0) {

   365 			PyOS_snprintf(p, sizeof(buf) - (p - buf),

   366 				      "argument %d", iarg);

   367 			i = 0;

   368 			p += strlen(p);

   369 			while (levels[i] > 0 && i < 32 && (int)(p-buf) < 220) {

   370 				PyOS_snprintf(p, sizeof(buf) - (p - buf),

   371 					      ", item %d", levels[i]-1);

   372 				p += strlen(p);

   373 				i++;

   374 			}

   375 		}

   376 		else {

   377 			PyOS_snprintf(p, sizeof(buf) - (p - buf), "argument");

   378 			p += strlen(p);

   379 		}

   380 		PyOS_snprintf(p, sizeof(buf) - (p - buf), " %.256s", msg);

   381 		message = buf;

   382 	}

   383 	PyErr_SetString(PyExc_TypeError, message);

   384 }

   385 

   386 

   387 /* Convert a tuple argument.

   388    On entry, *p_format points to the character _after_ the opening '('.

   389    On successful exit, *p_format points to the closing ')'.

   390    If successful:

   391       *p_format and *p_va are updated,

   392       *levels and *msgbuf are untouched,

   393       and NULL is returned.

   394    If the argument is invalid:

   395       *p_format is unchanged,

   396       *p_va is undefined,

   397       *levels is a 0-terminated list of item numbers,

   398       *msgbuf contains an error message, whose format is:

   399          "must be <typename1>, not <typename2>", where:

   400             <typename1> is the name of the expected type, and

   401             <typename2> is the name of the actual type,

   402       and msgbuf is returned.

   403 */

   404 

   405 static char *

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

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

   408              PyObject **freelist)

   409 {

   410 	int level = 0;

   411 	int n = 0;

   412 	const char *format = *p_format;

   413 	int i;

   414 	

   415 	for (;;) {

   416 		int c = *format++;

   417 		if (c == '(') {

   418 			if (level == 0)

   419 				n++;

   420 			level++;

   421 		}

   422 		else if (c == ')') {

   423 			if (level == 0)

   424 				break;

   425 			level--;

   426 		}

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

   428 			break;

   429 		else if (level == 0 && isalpha(Py_CHARMASK(c)))

   430 			n++;

   431 	}

   432 	

   433 	if (!PySequence_Check(arg) || PyString_Check(arg)) {

   434 		levels[0] = 0;

   435 		PyOS_snprintf(msgbuf, bufsize,

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

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

   438 			      n, 

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

   440 		return msgbuf;

   441 	}

   442 	

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

   444 		levels[0] = 0;

   445 		PyOS_snprintf(msgbuf, bufsize,

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

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

   448 			      n, i);

   449 		return msgbuf;

   450 	}

   451 

   452 	format = *p_format;

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

   454 		char *msg;

   455 		PyObject *item;

   456 		item = PySequence_GetItem(arg, i);

   457 		if (item == NULL) {

   458 			PyErr_Clear();

   459 			levels[0] = i+1;

   460 			levels[1] = 0;

   461 			strncpy(msgbuf, "is not retrievable", bufsize);

   462 			return msgbuf;

   463 		}

   464 		msg = convertitem(item, &format, p_va, flags, levels+1, 

   465 				  msgbuf, bufsize, freelist);

   466 		/* PySequence_GetItem calls tp->sq_item, which INCREFs */

   467 		Py_XDECREF(item);

   468 		if (msg != NULL) {

   469 			levels[0] = i+1;

   470 			return msg;

   471 		}

   472 	}

   473 

   474 	*p_format = format;

   475 	return NULL;

   476 }

   477 

   478 

   479 /* Convert a single item. */

   480 

   481 static char *

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

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

   484 {

   485 	char *msg;

   486 	const char *format = *p_format;

   487 	

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

   489 		format++;

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

   491 				   bufsize, 0, freelist);

   492 		if (msg == NULL)

   493 			format++;

   494 	}

   495 	else {

   496 		msg = convertsimple(arg, &format, p_va, flags, 

   497 				    msgbuf, bufsize, freelist);

   498 		if (msg != NULL)

   499 			levels[0] = 0;

   500 	}

   501 	if (msg == NULL)

   502 		*p_format = format;

   503 	return msg;

   504 }

   505 

   506 

   507 

   508 #define UNICODE_DEFAULT_ENCODING(arg) \

   509         _PyUnicode_AsDefaultEncodedString(arg, NULL)

   510 

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

   512 

   513 static char *

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

   515 {

   516 	assert(expected != NULL);

   517 	assert(arg != NULL); 

   518 	PyOS_snprintf(msgbuf, bufsize,

   519 		      "must be %.50s, not %.50s", expected,

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

   521 	return msgbuf;

   522 }

   523 

   524 #define CONV_UNICODE "(unicode conversion error)"

   525 

   526 /* explicitly check for float arguments when integers are expected.  For now

   527  * signal a warning.  Returns true if an exception was raised. */

   528 static int

   529 float_argument_error(PyObject *arg)

   530 {

   531 	if (PyFloat_Check(arg) &&

   532 	    PyErr_Warn(PyExc_DeprecationWarning,

   533 		       "integer argument expected, got float" ))

   534 		return 1;

   535 	else

   536 		return 0;

   537 }

   538 

   539 /* Convert a non-tuple argument.  Return NULL if conversion went OK,

   540    or a string with a message describing the failure.  The message is

   541    formatted as "must be <desired type>, not <actual type>".

   542    When failing, an exception may or may not have been raised.

   543    Don't call if a tuple is expected.

   544 

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

   546 */

   547 

   548 static char *

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

   550               char *msgbuf, size_t bufsize, PyObject **freelist)

   551 {

   552 	/* For # codes */

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

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

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

   556 #define STORE_SIZE(s)   if (flags & FLAG_SIZE_T) *q2=s; else *q=s;

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

   558 

   559 	const char *format = *p_format;

   560 	char c = *format++;

   561 #ifdef Py_USING_UNICODE

   562 	PyObject *uarg;

   563 #endif

   564 	

   565 	switch (c) {

   566 	

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

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

   569 		long ival;

   570 		if (float_argument_error(arg))

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

   572 		ival = PyInt_AsLong(arg);

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

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

   575 		else if (ival < 0) {

   576 			PyErr_SetString(PyExc_OverflowError,

   577 			"unsigned byte integer is less than minimum");

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

   579 		}

   580 		else if (ival > UCHAR_MAX) {

   581 			PyErr_SetString(PyExc_OverflowError,

   582 			"unsigned byte integer is greater than maximum");

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

   584 		}

   585 		else

   586 			*p = (unsigned char) ival;

   587 		break;

   588 	}

   589 	

   590 	case 'B': {/* byte sized bitfield - both signed and unsigned

   591 		      values allowed */  

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

   593 		long ival;

   594 		if (float_argument_error(arg))

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

   596 		ival = PyInt_AsUnsignedLongMask(arg);

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

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

   599 		else

   600 			*p = (unsigned char) ival;

   601 		break;

   602 	}

   603 	

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

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

   606 		long ival;

   607 		if (float_argument_error(arg))

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

   609 		ival = PyInt_AsLong(arg);

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

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

   612 		else if (ival < SHRT_MIN) {

   613 			PyErr_SetString(PyExc_OverflowError,

   614 			"signed short integer is less than minimum");

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

   616 		}

   617 		else if (ival > SHRT_MAX) {

   618 			PyErr_SetString(PyExc_OverflowError,

   619 			"signed short integer is greater than maximum");

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

   621 		}

   622 		else

   623 			*p = (short) ival;

   624 		break;

   625 	}

   626 	

   627 	case 'H': { /* short int sized bitfield, both signed and

   628 		       unsigned allowed */ 

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

   630 		long ival;

   631 		if (float_argument_error(arg))

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

   633 		ival = PyInt_AsUnsignedLongMask(arg);

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

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

   636 		else

   637 			*p = (unsigned short) ival;

   638 		break;

   639 	}

   640 

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

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

   643 		long ival;

   644 		if (float_argument_error(arg))

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

   646 		ival = PyInt_AsLong(arg);

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

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

   649 		else if (ival > INT_MAX) {

   650 			PyErr_SetString(PyExc_OverflowError,

   651 				"signed integer is greater than maximum");

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

   653 		}

   654 		else if (ival < INT_MIN) {

   655 			PyErr_SetString(PyExc_OverflowError,

   656 				"signed integer is less than minimum");

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

   658 		}

   659 		else

   660 			*p = ival;

   661 		break;

   662 	}

   663 

   664 	case 'I': { /* int sized bitfield, both signed and

   665 		       unsigned allowed */ 

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

   667 		unsigned int ival;

   668 		if (float_argument_error(arg))

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

   670 		ival = (unsigned int)PyInt_AsUnsignedLongMask(arg);

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

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

   673 		else

   674 			*p = ival;

   675 		break;

   676 	}

   677 	

   678 	case 'n': /* Py_ssize_t */

   679 #if SIZEOF_SIZE_T != SIZEOF_LONG

   680 	{

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

   682 		Py_ssize_t ival;

   683 		if (float_argument_error(arg))

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

   685 		ival = PyInt_AsSsize_t(arg);

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

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

   688 		*p = ival;

   689 		break;

   690 	}

   691 #endif

   692 	/* Fall through from 'n' to 'l' if Py_ssize_t is int */

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

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

   695 		long ival;

   696 		if (float_argument_error(arg))

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

   698 		ival = PyInt_AsLong(arg);

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

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

   701 		else

   702 			*p = ival;

   703 		break;

   704 	}

   705 

   706 	case 'k': { /* long sized bitfield */

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

   708 		unsigned long ival;

   709 		if (PyInt_Check(arg))

   710 			ival = PyInt_AsUnsignedLongMask(arg);

   711 		else if (PyLong_Check(arg))

   712 			ival = PyLong_AsUnsignedLongMask(arg);

   713 		else

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

   715 		*p = ival;

   716 		break;

   717 	}

   718 	

   719 #ifdef HAVE_LONG_LONG

   720 	case 'L': {/* PY_LONG_LONG */

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

   722 		PY_LONG_LONG ival = PyLong_AsLongLong( arg );

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

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

   725 		} else {

   726 			*p = ival;

   727 		}

   728 		break;

   729 	}

   730 

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

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

   733 		unsigned PY_LONG_LONG ival;

   734 		if (PyInt_Check(arg))

   735 			ival = PyInt_AsUnsignedLongMask(arg);

   736 		else if (PyLong_Check(arg))

   737 			ival = PyLong_AsUnsignedLongLongMask(arg);

   738 		else

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

   740 		*p = ival;

   741 		break;

   742 	}

   743 #endif

   744 	

   745 	case 'f': {/* float */

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

   747 		double dval = PyFloat_AsDouble(arg);

   748 		if (PyErr_Occurred())

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

   750 		else

   751 			*p = (float) dval;

   752 		break;

   753 	}

   754 	

   755 	case 'd': {/* double */

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

   757 		double dval = PyFloat_AsDouble(arg);

   758 		if (PyErr_Occurred())

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

   760 		else

   761 			*p = dval;

   762 		break;

   763 	}

   764 	

   765 #ifndef WITHOUT_COMPLEX

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

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

   768 		Py_complex cval;

   769 		cval = PyComplex_AsCComplex(arg);

   770 		if (PyErr_Occurred())

   771 			return converterr("complex<D>", arg, msgbuf, bufsize);

   772 		else

   773 			*p = cval;

   774 		break;

   775 	}

   776 #endif /* WITHOUT_COMPLEX */

   777 	

   778 	case 'c': {/* char */

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

   780 		if (PyString_Check(arg) && PyString_Size(arg) == 1)

   781 			*p = PyString_AS_STRING(arg)[0];

   782 		else

   783 			return converterr("char", arg, msgbuf, bufsize);

   784 		break;

   785 	}

   786 	

   787 	case 's': {/* string */

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

   789 			Py_buffer *p = (Py_buffer *)va_arg(*p_va, Py_buffer *);

   790 

   791 			if (PyString_Check(arg)) {

   792 				PyBuffer_FillInfo(p, arg,

   793 						  PyString_AS_STRING(arg), PyString_GET_SIZE(arg),

   794 						  1, 0);

   795 			}

   796 #ifdef Py_USING_UNICODE

   797 			else if (PyUnicode_Check(arg)) {

   798 				uarg = UNICODE_DEFAULT_ENCODING(arg);

   799 				if (uarg == NULL)

   800 					return converterr(CONV_UNICODE,

   801 							  arg, msgbuf, bufsize);

   802 				PyBuffer_FillInfo(p, arg,

   803 						  PyString_AS_STRING(uarg), PyString_GET_SIZE(uarg),

   804 						  1, 0);

   805 			}

   806 #endif

   807 			else { /* any buffer-like object */

   808 				char *buf;

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

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

   811 			}

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

   813 				return converterr(

   814 					"(cleanup problem)",

   815 					arg, msgbuf, bufsize);

   816 			}

   817 			format++;

   818 		} else if (*format == '#') {

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

   820 			FETCH_SIZE;

   821 			

   822 			if (PyString_Check(arg)) {

   823 				*p = PyString_AS_STRING(arg);

   824 				STORE_SIZE(PyString_GET_SIZE(arg));

   825 			}

   826 #ifdef Py_USING_UNICODE

   827 			else if (PyUnicode_Check(arg)) {

   828 				uarg = UNICODE_DEFAULT_ENCODING(arg);

   829 				if (uarg == NULL)

   830 					return converterr(CONV_UNICODE,

   831 							  arg, msgbuf, bufsize);

   832 				*p = PyString_AS_STRING(uarg);

   833 				STORE_SIZE(PyString_GET_SIZE(uarg));

   834 			}

   835 #endif

   836 			else { /* any buffer-like object */

   837 				char *buf;

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

   839 				if (count < 0)

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

   841 				STORE_SIZE(count);

   842 			}

   843 			format++;

   844 		} else {

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

   846 			

   847 			if (PyString_Check(arg))

   848 				*p = PyString_AS_STRING(arg);

   849 #ifdef Py_USING_UNICODE

   850 			else if (PyUnicode_Check(arg)) {

   851 				uarg = UNICODE_DEFAULT_ENCODING(arg);

   852 				if (uarg == NULL)

   853 					return converterr(CONV_UNICODE,

   854 							  arg, msgbuf, bufsize);

   855 				*p = PyString_AS_STRING(uarg);

   856 			}

   857 #endif

   858 			else

   859 				return converterr("string", arg, msgbuf, bufsize);

   860 			if ((Py_ssize_t)strlen(*p) != PyString_Size(arg))

   861 				return converterr("string without null bytes",

   862 						  arg, msgbuf, bufsize);

   863 		}

   864 		break;

   865 	}

   866 

   867 	case 'z': {/* string, may be NULL (None) */

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

   869 			Py_buffer *p = (Py_buffer *)va_arg(*p_va, Py_buffer *);

   870 

   871 			if (arg == Py_None)

   872 				PyBuffer_FillInfo(p, NULL, NULL, 0, 1, 0);

   873 			else if (PyString_Check(arg)) {

   874 				PyBuffer_FillInfo(p, arg,

   875 						  PyString_AS_STRING(arg), PyString_GET_SIZE(arg),

   876 						  1, 0);

   877 			}

   878 #ifdef Py_USING_UNICODE

   879 			else if (PyUnicode_Check(arg)) {

   880 				uarg = UNICODE_DEFAULT_ENCODING(arg);

   881 				if (uarg == NULL)

   882 					return converterr(CONV_UNICODE,

   883 							  arg, msgbuf, bufsize);

   884 				PyBuffer_FillInfo(p, arg,

   885 						  PyString_AS_STRING(uarg), PyString_GET_SIZE(uarg),

   886 						  1, 0);

   887 			}

   888 #endif

   889 			else { /* any buffer-like object */

   890 				char *buf;

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

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

   893 			}

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

   895 				return converterr(

   896 					"(cleanup problem)",

   897 					arg, msgbuf, bufsize);

   898 			}

   899 			format++;

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

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

   902 			FETCH_SIZE;

   903 			

   904 			if (arg == Py_None) {

   905 				*p = 0;

   906 				STORE_SIZE(0);

   907 			}

   908 			else if (PyString_Check(arg)) {

   909 				*p = PyString_AS_STRING(arg);

   910 				STORE_SIZE(PyString_GET_SIZE(arg));

   911 			}

   912 #ifdef Py_USING_UNICODE

   913 			else if (PyUnicode_Check(arg)) {

   914 				uarg = UNICODE_DEFAULT_ENCODING(arg);

   915 				if (uarg == NULL)

   916 					return converterr(CONV_UNICODE,

   917 							  arg, msgbuf, bufsize);

   918 				*p = PyString_AS_STRING(uarg);

   919 				STORE_SIZE(PyString_GET_SIZE(uarg));

   920 			}

   921 #endif

   922 			else { /* any buffer-like object */

   923 				char *buf;

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

   925 				if (count < 0)

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

   927 				STORE_SIZE(count);

   928 			}

   929 			format++;

   930 		} else {

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

   932 			

   933 			if (arg == Py_None)

   934 				*p = 0;

   935 			else if (PyString_Check(arg))

   936 				*p = PyString_AS_STRING(arg);

   937 #ifdef Py_USING_UNICODE

   938 			else if (PyUnicode_Check(arg)) {

   939 				uarg = UNICODE_DEFAULT_ENCODING(arg);

   940 				if (uarg == NULL)

   941 					return converterr(CONV_UNICODE,

   942 							  arg, msgbuf, bufsize);

   943 				*p = PyString_AS_STRING(uarg);

   944 			}

   945 #endif

   946 			else

   947 				return converterr("string or None", 

   948 						  arg, msgbuf, bufsize);

   949 			if (*format == '#') {

   950 				FETCH_SIZE;

   951 				assert(0); /* XXX redundant with if-case */

   952 				if (arg == Py_None)

   953 					*q = 0;

   954 				else

   955 					*q = PyString_Size(arg);

   956 				format++;

   957 			}

   958 			else if (*p != NULL &&

   959 				 (Py_ssize_t)strlen(*p) != PyString_Size(arg))

   960 				return converterr(

   961 					"string without null bytes or None", 

   962 					arg, msgbuf, bufsize);

   963 		}

   964 		break;

   965 	}

   966 	

   967 	case 'e': {/* encoded string */

   968 		char **buffer;

   969 		const char *encoding;

   970 		PyObject *s;

   971 		Py_ssize_t size;

   972 		int recode_strings;

   973 

   974 		/* Get 'e' parameter: the encoding name */

   975 		encoding = (const char *)va_arg(*p_va, const char *);

   976 #ifdef Py_USING_UNICODE

   977 		if (encoding == NULL)

   978 			encoding = PyUnicode_GetDefaultEncoding();

   979 #endif

   980 			

   981 		/* Get output buffer parameter:

   982 		   's' (recode all objects via Unicode) or

   983 		   't' (only recode non-string objects) 

   984 		*/

   985 		if (*format == 's')

   986 			recode_strings = 1;

   987 		else if (*format == 't')

   988 			recode_strings = 0;

   989 		else

   990 			return converterr(

   991 				"(unknown parser marker combination)",

   992 				arg, msgbuf, bufsize);

   993 		buffer = (char **)va_arg(*p_va, char **);

   994 		format++;

   995 		if (buffer == NULL)

   996 			return converterr("(buffer is NULL)", 

   997 					  arg, msgbuf, bufsize);

   998 			

   999 		/* Encode object */

  1000 		if (!recode_strings && PyString_Check(arg)) {

  1001 			s = arg;

  1002 			Py_INCREF(s);

  1003 		}

  1004 		else {

  1005 #ifdef Py_USING_UNICODE

  1006 		    	PyObject *u;

  1007 

  1008 			/* Convert object to Unicode */

  1009 			u = PyUnicode_FromObject(arg);

  1010 			if (u == NULL)

  1011 				return converterr(

  1012 					"string or unicode or text buffer", 

  1013 					arg, msgbuf, bufsize);

  1014 			

  1015 			/* Encode object; use default error handling */

  1016 			s = PyUnicode_AsEncodedString(u,

  1017 						      encoding,

  1018 						      NULL);

  1019 			Py_DECREF(u);

  1020 			if (s == NULL)

  1021 				return converterr("(encoding failed)",

  1022 						  arg, msgbuf, bufsize);

  1023 			if (!PyString_Check(s)) {

  1024 				Py_DECREF(s);

  1025 				return converterr(

  1026 					"(encoder failed to return a string)",

  1027 					arg, msgbuf, bufsize);

  1028 			}

  1029 #else

  1030 			return converterr("string<e>", arg, msgbuf, bufsize);

  1031 #endif

  1032 		}

  1033 		size = PyString_GET_SIZE(s);

  1034 

  1035 		/* Write output; output is guaranteed to be 0-terminated */

  1036 		if (*format == '#') { 

  1037 			/* Using buffer length parameter '#':

  1038 				   

  1039 			   - if *buffer is NULL, a new buffer of the

  1040 			   needed size is allocated and the data

  1041 			   copied into it; *buffer is updated to point

  1042 			   to the new buffer; the caller is

  1043 			   responsible for PyMem_Free()ing it after

  1044 			   usage 

  1045 

  1046 			   - if *buffer is not NULL, the data is

  1047 			   copied to *buffer; *buffer_len has to be

  1048 			   set to the size of the buffer on input;

  1049 			   buffer overflow is signalled with an error;

  1050 			   buffer has to provide enough room for the

  1051 			   encoded string plus the trailing 0-byte

  1052 			   

  1053 			   - in both cases, *buffer_len is updated to

  1054 			   the size of the buffer /excluding/ the

  1055 			   trailing 0-byte 

  1056 			   

  1057 			*/

  1058 			FETCH_SIZE;

  1059 

  1060 			format++;

  1061 			if (q == NULL && q2 == NULL) {

  1062 				Py_DECREF(s);

  1063 				return converterr(

  1064 					"(buffer_len is NULL)",

  1065 					arg, msgbuf, bufsize);

  1066 			}

  1067 			if (*buffer == NULL) {

  1068 				*buffer = PyMem_NEW(char, size + 1);

  1069 				if (*buffer == NULL) {

  1070 					Py_DECREF(s);

  1071 					return converterr(

  1072 						"(memory error)",

  1073 						arg, msgbuf, bufsize);

  1074 				}

  1075 				if (addcleanup(*buffer, freelist, cleanup_ptr)) {

  1076 					Py_DECREF(s);

  1077 					return converterr(

  1078 						"(cleanup problem)",

  1079 						arg, msgbuf, bufsize);

  1080 				}

  1081 			} else {

  1082 				if (size + 1 > BUFFER_LEN) {

  1083 					Py_DECREF(s);

  1084 					return converterr(

  1085 						"(buffer overflow)", 

  1086 						arg, msgbuf, bufsize);

  1087 				}

  1088 			}

  1089 			memcpy(*buffer,

  1090 			       PyString_AS_STRING(s),

  1091 			       size + 1);

  1092 			STORE_SIZE(size);

  1093 		} else {

  1094 			/* Using a 0-terminated buffer:

  1095 				   

  1096 			   - the encoded string has to be 0-terminated

  1097 			   for this variant to work; if it is not, an

  1098 			   error raised 

  1099 

  1100 			   - a new buffer of the needed size is

  1101 			   allocated and the data copied into it;

  1102 			   *buffer is updated to point to the new

  1103 			   buffer; the caller is responsible for

  1104 			   PyMem_Free()ing it after usage

  1105 

  1106 			*/

  1107 			if ((Py_ssize_t)strlen(PyString_AS_STRING(s))

  1108 								!= size) {

  1109 				Py_DECREF(s);

  1110 				return converterr(

  1111 					"(encoded string without NULL bytes)",

  1112 					arg, msgbuf, bufsize);

  1113 			}

  1114 			*buffer = PyMem_NEW(char, size + 1);

  1115 			if (*buffer == NULL) {

  1116 				Py_DECREF(s);

  1117 				return converterr("(memory error)",

  1118 						  arg, msgbuf, bufsize);

  1119 			}

  1120 			if (addcleanup(*buffer, freelist, cleanup_ptr)) {

  1121 				Py_DECREF(s);

  1122 				return converterr("(cleanup problem)",

  1123 						arg, msgbuf, bufsize);

  1124 			}

  1125 			memcpy(*buffer,

  1126 			       PyString_AS_STRING(s),

  1127 			       size + 1);

  1128 		}

  1129 		Py_DECREF(s);

  1130 		break;

  1131 	}

  1132 

  1133 #ifdef Py_USING_UNICODE

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

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