PageRenderTime 913ms CodeModel.GetById 121ms app.highlight 601ms RepoModel.GetById 172ms app.codeStats 1ms

/Python/getargs.c

http://unladen-swallow.googlecode.com/
C | 1871 lines | 1578 code | 179 blank | 114 comment | 484 complexity | c12cb689e1fe7654bf93054bb6554d2e MD5 | raw file
   1
   2/* New getargs implementation */
   3
   4#include "Python.h"
   5
   6#include <ctype.h>
   7
   8
   9#ifdef __cplusplus
  10extern "C" { 
  11#endif
  12int PyArg_Parse(PyObject *, const char *, ...);
  13int PyArg_ParseTuple(PyObject *, const char *, ...);
  14int PyArg_VaParse(PyObject *, const char *, va_list);
  15
  16int PyArg_ParseTupleAndKeywords(PyObject *, PyObject *,
  17				const char *, char **, ...);
  18int PyArg_VaParseTupleAndKeywords(PyObject *, PyObject *,
  19				const char *, char **, va_list);
  20
  21#ifdef HAVE_DECLSPEC_DLL
  22/* Export functions */
  23PyAPI_FUNC(int) _PyArg_Parse_SizeT(PyObject *, char *, ...);
  24PyAPI_FUNC(int) _PyArg_ParseTuple_SizeT(PyObject *, char *, ...);
  25PyAPI_FUNC(int) _PyArg_ParseTupleAndKeywords_SizeT(PyObject *, PyObject *,
  26                                                  const char *, char **, ...);
  27PyAPI_FUNC(PyObject *) _Py_BuildValue_SizeT(const char *, ...);
  28PyAPI_FUNC(int) _PyArg_VaParse_SizeT(PyObject *, char *, va_list);
  29PyAPI_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 */
  38static int vgetargs1(PyObject *, const char *, va_list *, int);
  39static void seterror(int, const char *, int *, const char *, const char *);
  40static char *convertitem(PyObject *, const char **, va_list *, int, int *, 
  41                         char *, size_t, PyObject **);
  42static char *converttuple(PyObject *, const char **, va_list *, int,
  43			  int *, char *, size_t, int, PyObject **);
  44static char *convertsimple(PyObject *, const char **, va_list *, int, char *,
  45			   size_t, PyObject **);
  46static Py_ssize_t convertbuffer(PyObject *, void **p, char **);
  47static int getbuffer(PyObject *, Py_buffer *, char**);
  48
  49static int vgetargskeywords(PyObject *, PyObject *,
  50			    const char *, char **, va_list *, int);
  51static char *skipitem(const char **, va_list *, int);
  52
  53int
  54PyArg_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
  65int
  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
  78int
  79PyArg_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
  90int
  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
 103int
 104PyArg_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
 121int
 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
 142static void
 143cleanup_ptr(void *ptr)
 144{
 145	PyMem_FREE(ptr);
 146}
 147
 148static void
 149cleanup_buffer(void *ptr)
 150{
 151	PyBuffer_Release((Py_buffer *) ptr);
 152}
 153
 154static int
 155addcleanup(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
 178static int
 179cleanreturn(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
 194static int
 195vgetargs1(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
 349static void
 350seterror(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
 405static char *
 406converttuple(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
 481static char *
 482convertitem(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
 513static char *
 514converterr(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. */
 528static int
 529float_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
 548static char *
 549convertsimple(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 */
1136			void **p = (void **)va_arg(*p_va, char **);
1137			FETCH_SIZE;
1138			if (PyUnicode_Check(arg)) {
1139			    	*p = PyUnicode_AS_UNICODE(arg);
1140				STORE_SIZE(PyUnicode_GET_SIZE(arg));
1141			}
1142			else {
1143				return converterr("cannot convert raw buffers",
1144						  arg, msgbuf, bufsize);
1145			}
1146			format++;
1147		} else {
1148			Py_UNICODE **p = va_arg(*p_va, Py_UNICODE **);
1149			if (PyUnicode_Check(arg))
1150				*p = PyUnicode_AS_UNICODE(arg);
1151			else
1152				return converterr("unicode", arg, msgbuf, bufsize);
1153		}
1154		break;
1155	}
1156#endif
1157
1158	case 'S': { /* string object */
1159		PyObject **p = va_arg(*p_va, PyObject **);
1160		if (PyString_Check(arg))
1161			*p = arg;
1162		else
1163			return converterr("string", arg, msgbuf, bufsize);
1164		break;
1165	}
1166	
1167#ifdef Py_USING_UNICODE
1168	case 'U': { /* Unicode object */
1169		PyObject **p = va_arg(*p_va, PyObject **);
1170		if (PyUnicode_Check(arg))
1171			*p = arg;
1172		else
1173			return converterr("unicode", arg, msgbuf, bufsize);
1174		break;
1175	}
1176#endif
1177	
1178	case 'O': { /* object */
1179		PyTypeObject *type;
1180		PyObject **p;
1181		if (*format == '!') {
1182			type = va_arg(*p_va, PyTypeObject*);
1183			p = va_arg(*p_va, PyObject **);
1184			format++;
1185			if (PyType_IsSubtype(arg->ob_type, type))
1186				*p = arg;
1187			else
1188				return converterr(type->tp_name, arg, msgbuf, bufsize);
1189
1190		}
1191		else if (*format == '?') {
1192			inquiry pred = va_arg(*p_va, inquiry);
1193			p = va_arg(*p_va, PyObject **);
1194			format++;
1195			if ((*pred)(arg)) 
1196				*p = arg;
1197			else
1198				return converterr("(unspecified)", 
1199						  arg, msgbuf, bufsize);
1200				
1201		}
1202		else if (*format == '&') {
1203			typedef int (*converter)(PyObject *, void *);
1204			converter convert = va_arg(*p_va, converter);
1205			void *addr = va_arg(*p_va, void *);
1206			format++;
1207			if (! (*convert)(arg, addr))
1208				return converterr("(unspecified)", 
1209						  arg, msgbuf, bufsize);
1210		}
1211		else {
1212			p = va_arg(*p_va, PyObject **);
1213			*p = arg;
1214		}
1215		break;
1216	}
1217		
1218		
1219	case 'w': { /* memory buffer, read-write access */
1220		void **p = va_arg(*p_va, void **);
1221		void *res;
1222		PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
1223		Py_ssize_t count;
1224
1225		if (pb && pb->bf_releasebuffer && *format != '*')
1226			/* Buffer must be released, yet caller does not use
1227			   the Py_buffer protocol. */
1228			return converterr("pinned buffer", arg, msgbuf, bufsize);
1229
1230		if (pb && pb->bf_getbuffer && *format == '*') {
1231			/* Caller is interested in Py_buffer, and the object
1232			   supports it directly. */
1233			format++;
1234			if (pb->bf_getbuffer(arg, (Py_buffer*)p, PyBUF_WRITABLE) < 0) {
1235				PyErr_Clear();
1236				return converterr("read-write buffer", arg, msgbuf, bufsize);
1237			}
1238			if (addcleanup(p, freelist, cleanup_buffer)) {
1239				return converterr(
1240					"(cleanup problem)",
1241					arg, msgbuf, bufsize);
1242			}
1243			if (!PyBuffer_IsContiguous((Py_buffer*)p, 'C'))
1244				return converterr("contiguous buffer", arg, msgbuf, bufsize);
1245			break;
1246		}
1247
1248		if (pb == NULL ||
1249		    pb->bf_getwritebuffer == NULL ||
1250		    pb->bf_getsegcount == NULL)
1251			return converterr("read-write buffer", arg, msgbuf, bufsize);
1252		if ((*pb->bf_getsegcount)(arg, NULL) != 1)
1253			return converterr("single-segment read-write buffer", 
1254					  arg, msgbuf, bufsize);
1255		if ((count = pb->bf_getwritebuffer(arg, 0, &res)) < 0)
1256			return converterr("(unspecified)", arg, msgbuf, bufsize);
1257		if (*format == '*') {
1258			PyBuffer_FillInfo((Py_buffer*)p, arg, res, count, 1, 0);
1259			format++;
1260		}
1261		else {
1262			*p = res;
1263			if (*format == '#') {
1264				FETCH_SIZE;
1265				STORE_SIZE(count);
1266				format++;
1267			}
1268		}
1269		break;
1270	}
1271		
1272	case 't': { /* 8-bit character buffer, read-only access */
1273		char **p = va_arg(*p_va, char **);
1274		PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
1275		Py_ssize_t count;
1276		
1277		if (*format++ != '#')
1278			return converterr(
1279				"invalid use of 't' format character", 
1280				arg, msgbuf, bufsize);
1281		if (!PyType_HasFeature(arg->ob_type,
1282				       Py_TPFLAGS_HAVE_GETCHARBUFFER) ||
1283		    pb == NULL || pb->bf_getcharbuffer == NULL ||
1284		    pb->bf_getsegcount == NULL)
1285			return converterr(
1286				"string or read-only character buffer",
1287				arg, msgbuf, bufsize);
1288
1289		if (pb->bf_getsegcount(arg, NULL) != 1)
1290			return converterr(
1291				"string or single-segment read-only buffer",
1292				arg, msgbuf, bufsize);
1293
1294		if (pb->bf_releasebuffer)
1295			return converterr(
1296				"string or pinned buffer",
1297				arg, msgbuf, bufsize);
1298
1299		count = pb->bf_getcharbuffer(arg, 0, p);
1300		if (count < 0)
1301			return converterr("(unspecified)", arg, msgbuf, bufsize);
1302		{
1303			FETCH_SIZE;
1304			STORE_SIZE(count);
1305		}
1306		break;
1307	}
1308
1309	default:
1310		return converterr("impossible<bad format char>", arg, msgbuf, bufsize);
1311	
1312	}
1313	
1314	*p_format = format;
1315	return NULL;
1316}
1317
1318static Py_ssize_t
1319convertbuffer(PyObject *arg, void **p, char **errmsg)
1320{
1321	PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
1322	Py_ssize_t count;
1323	if (pb == NULL ||
1324	    pb->bf_getreadbuffer == NULL ||
1325	    pb->bf_getsegcount == NULL ||
1326	    pb->bf_releasebuffer != NULL) {
1327		*errmsg = "string or read-only buffer";
1328		return -1;
1329	}
1330	if ((*pb->bf_getsegcount)(arg, NULL) != 1) {
1331		*errmsg = "string or single-segment read-only buffer";
1332		return -1;
1333	}
1334	if ((count = (*pb->bf_getreadbuffer)(arg, 0, p)) < 0) {
1335		*errmsg = "(unspecified)";
1336	}
1337	return count;
1338}
1339
1340static int
1341getbuffer(PyObject *arg, Py_buffer *view, char **errmsg)
1342{
1343	void *buf;
1344	Py_ssize_t count;
1345	PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
1346	if (pb == NULL) {
1347		*errmsg = "string or buffer";
1348		return -1;
1349	}
1350	if (pb->bf_getbuffer) {
1351		if (pb->bf_getbuffer(arg, view, 0) < 0) {
1352			*errmsg = "convertible to a buffer";
1353			return -1;
1354		}
1355		if (!PyBuffer_IsContiguous(view, 'C')) {
1356			*errmsg = "contiguous buffer";
1357			return -1;
1358		}
1359		return 0;
1360	}
1361
1362	count = convertbuffer(arg, &buf, errmsg);
1363	if (count < 0) {
1364		*errmsg = "convertible to a buffer";
1365		return count;
1366	}
1367	PyBuffer_FillInfo(view, NULL, buf, count, 1, 0);
1368	return 0;
1369}
1370
1371/* Support for keyword arguments donated by
1372   Geoff Philbrick <philbric@delphi.hks.com> */
1373
1374/* Return false (0) for error, else true. */
1375int
1376PyArg_ParseTupleAndKeywords(PyObject *args,
1377			    PyObject *keywords,
1378			    const char *format, 
1379			    char **kwlist, ...)
1380{
1381	int retval;
1382	va_list va;
1383
1384	if ((args == NULL || !PyTuple_Check(args)) ||
1385	    (keywords != NULL && !PyDict_Check(keywords)) ||
1386	    format == NULL ||
1387	    kwlist == NULL)
1388	{
1389		PyErr_BadInternalCall();
1390		return 0;
1391	}
1392
1393	va_start(va, kwlist);
1394	retval = vgetargskeywords(args, keywords, format, kwlist, &va, 0);	
1395	va_end(va);
1396	return retval;
1397}
1398
1399int
1400_PyArg_ParseTupleAndKeywords_SizeT(PyObject *args,
1401				  PyObject *keywords,
1402				  const char *format, 
1403				  char **kwlist, ...)
1404{
1405	int retval;
1406	va_list va;
1407
1408	if ((args == NULL || !PyTuple_Check(args)) ||
1409	    (keywords != NULL && !PyDict_Check(keywords)) ||
1410	    format == NULL ||
1411	    kwlist == NULL)
1412	{
1413		PyErr_BadInternalCall();
1414		return 0;
1415	}
1416
1417	va_start(va, kwlist);
1418	retval = vgetargskeywords(args, keywords, format, 
1419				  kwlist, &va, FLAG_SIZE_T);
1420	va_end(va);
1421	return retval;
1422}
1423
1424
1425int
1426PyArg_VaParseTupleAndKeywords(PyObject *args,
1427                              PyObject *keywords,
1428                              const char *format, 
1429                              char **kwlist, va_list va)
1430{
1431	int retval;
1432	va_list lva;
1433
1434	if ((args == NULL || !PyTuple_Check(args)) ||
1435	    (keywords != NULL && !PyDict_Check(keywords)) ||
1436	    format == NULL ||
1437	    kwlist == NULL)
1438	{
1439		PyErr_BadInternalCall();
1440		return 0;
1441	}
1442
1443#ifdef VA_LIST_IS_ARRAY
1444	memcpy(lva, va, sizeof(va_list));
1445#else
1446#ifdef __va_copy
1447	__va_copy(lva, va);
1448#else
1449	lva = va;
1450#endif
1451#endif
1452
1453	retval = vgetargskeywords(args, keywords, format, kwlist, &lva, 0);	
1454	return retval;
1455}
1456
1457int
1458_PyArg_VaParseTupleAndKeywords_SizeT(PyObject *args,
1459				    PyObject *keywords,
1460				    const char *format, 
1461				    char **kwlist, va_list va)
1462{
1463	int retval;
1464	va_list lva;
1465
1466	if ((args == NULL || !PyTuple_Check(args)) ||
1467	    (keywords != NULL && !PyDict_Check(keywords)) ||
1468	    format == NULL ||
1469	    kwlist == NULL)
1470	{
1471		PyErr_BadInternalCall();
1472		return 0;
1473	}
1474
1475#ifdef VA_LIST_IS_ARRAY
1476	memcpy(lva, va, sizeof(va_list));
1477#else
1478#ifdef __va_copy
1479	__va_copy(lva, va);
1480#else
1481	lva = va;
1482#endif
1483#endif
1484
1485	retval = vgetargskeywords(args, keywords, format, 
1486				  kwlist, &lva, FLAG_SIZE_T);
1487	return retval;
1488}
1489
1490#define IS_END_OF_FORMAT(c) (c == '\0' || c == ';' || c == ':')
1491
1492static int
1493vgetargskeywords(PyObject *args, PyObject *keywords, const char *format,
1494	         char **kwlist, va_list *p_va, int flags)
1495{
1496	char msgbuf[512];
1497	int levels[32];
1498	const char *fname, *msg, *custom_msg, *keyword;
1499	int min = INT_MAX;
1500	int i, len, nargs, nkeywords;
1501	PyObject *freelist = NULL, *current_arg;
1502
1503	assert(args != NULL && PyTuple_Check(args));
1504	assert(keywords == NULL || PyDict_Check(keywords));
1505	assert(format != NULL);
1506	assert(kwlist != NULL);
1507	assert(p_va != NULL);
1508
1509	/* grab the function name or custom error msg first (mutually exclusive) */
1510	fname = strchr(format, ':');
1511	if (fname) {
1512		fname++;
1513		custom_msg = NULL;
1514	}
1515	else {
1516		custom_msg = strchr(format,';');
1517		if (custom_msg)
1518			custom_msg++;
1519	}
1520
1521	/* scan kwlist and get greatest possible nbr of args */
1522	for (len=0; kwlist[len]; len++)
1523		continue;
1524
1525	nargs = PyTuple_GET_SIZE(args);
1526	nkeywords = (keywords == NULL) ? 0 : PyDict_Size(keywords);
1527	if (nargs + nkeywords > len) {
1528		PyErr_Format(PyExc_TypeError, "%s%s takes at most %d "
1529			     "argument%s (%d given)",
1530			     (fname == NULL) ? "function" : fname,
1531			     (fname == NULL) ? "" : "()",
1532			     len,
1533			     (len == 1) ? "" : "s",
1534			     nargs + nkeywords);
1535		return 0;
1536	}
1537
1538	/* convert tuple args and keyword args in same loop, using kwlist to drive process */
1539	for (i = 0; i < len; i++) {
1540		keyword = kwlist[i];
1541		if (*format == '|') {
1542			min = i;
1543			format++;
1544		}
1545		if (IS_END_OF_FORMAT(*format)) {
1546			PyErr_Format(PyExc_RuntimeError,
1547				     "More keyword list entries (%d) than "
1548				     "format specifiers (%d)", len, i);
1549			return cleanreturn(0, freelist);
1550		}
1551		current_arg = NULL;
1552		if (nkeywords) {
1553			current_arg = PyDict_GetItemString(keywords, keyword);
1554		}
1555		if (current_arg) {
1556			--nkeywords;
1557			if (i < nargs) {
1558				/* arg present in tuple and in dict */
1559				PyErr_Format(PyExc_TypeError,
1560					     "Argument given by name ('%s') "
1561					     "and position (%d)",
1562					     keyword, i+1);
1563				return cleanreturn(0, freelist);
1564			}
1565		}
1566		else if (nkeywords && PyErr_Occurred())
1567			return cleanreturn(0, freelist);
1568		else if (i < nargs)
1569			current_arg = PyTuple_GET_ITEM(args, i);
1570			
1571		if (current_arg) {
1572			msg = convertitem(current_arg, &format, p_va, flags,
1573				levels, msgbuf, sizeof(msgbuf), &freelist);
1574			if (msg) {
1575				seterror(i+1, msg, levels, fname, custom_msg);
1576				return cleanreturn(0, freelist);
1577			}
1578			continue;
1579		}
1580
1581		if (i < min) {
1582			PyErr_Format(PyExc_TypeError, "Required argument "
1583				     "'%s' (pos %d) not found",
1584				     keyword, i+1);
1585			return cleanreturn(0, freelist);
1586		}
1587		/* current code reports success when all required args
1588		 * fulfilled and no keyword args left, with no further
1589		 * validation. XXX Maybe skip this in debug build ?
1590		 */
1591		if (!nkeywords)
1592			return cleanreturn(1, freelist);
1593
1594		/* We are into optional args, skip thru to any remaining
1595		 * keyword args */
1596		msg = skipitem(&format, p_va, flags);
1597		if (msg) {
1598			PyErr_Format(PyExc_RuntimeError, "%s: '%s'", msg,
1599				     format);
1600			return cleanreturn(0, freelist);
1601		}
1602	}
1603
1604	if (!IS_END_OF_FORMAT(*format) && *format != '|') {
1605		PyErr_Format(PyExc_RuntimeError,
1606			"more argument specifiers than keyword list entries "
1607			"(remaining format:'%s')", format);
1608		return cleanreturn(0, freelist);
1609	}
1610
1611	/* make sure there are no extraneous keyword arguments */
1612	if (nkeywords > 0) {
1613		PyObject *key, *value;
1614		Py_ssize_t pos = 0;
1615		while (PyDict_Next(keywords, &pos, &key, &value)) {
1616			int match = 0;
1617			char *ks;
1618			if (!PyString_Check(key)) {
1619				PyErr_SetString(PyExc_TypeError, 
1620					        "keywords must be strings");
1621				return cleanreturn(0, freelist);
1622			}
1623			ks = PyString_AsString(key);
1624			for (i = 0; i < len; i++) {
1625				if (!strcmp(ks, kwlist[i])) {
1626					match = 1;
1627					break;
1628				}
1629			}
1630			if (!match) {
1631				PyErr_Format(PyExc_TypeError,
1632					     "'%s' is an invalid keyword "
1633					     "argument for this function",
1634					     ks);
1635				return cleanreturn(0, freelist);
1636			}
1637		}
1638	}
1639
1640	return cleanreturn(1, freelist);
1641}
1642
1643
1644static char *
1645skipitem(const char **p_format, va_list *p_va, int flags)
1646{
1647	const char *format = *p_format;
1648	char c = *format++;
1649	
1650	switch (c) {
1651
1652	/* simple codes
1653	 * The individual types (second arg of va_arg) are irrelevant */
1654
1655	case 'b': /* byte -- very short int */
1656	case 'B': /* byte as bitfield */
1657	case 'h': /* short int */
1658	case 'H': /* short int as bitfield */
1659	case 'i': /* int */
1660	case 'I': /* int sized bitfield */
1661	case 'l': /* long int */
1662	case 'k': /* long int sized bitfield */
1663#ifdef HAVE_LONG_LONG
1664	case 'L': /* PY_LONG_LONG */
1665	case 'K': /* PY_LONG_LONG sized bitfield */
1666#endif
1667	case 'f': /* float */
1668	case 'd': /* double */
1669#ifndef WITHOUT_COMPLEX
1670	case 'D': /* complex double */
1671#endif
1672	case 'c': /* char */
1673		{
1674			(void) va_arg(*p_va, void *);
1675			break;
1676		}
1677
1678	case 'n': /* Py_ssize_t */
1679		{
1680			(void) va_arg(*p_va, Py_ssize_t *);
1681			break;
1682		}
1683	
1684	/* string codes */
1685		
1686	case 'e': /* string with encoding */
1687		{
1688			(void) va_arg(*p_va, const char *);
1689			if (!(*format == 's' || *format == 't'))
1690				/* after 'e', only 's' and 't' is allowed */
1691				goto err;
1692			format++;
1693			/* explicit fallthrough to string cases */
1694		}
1695	
1696	case 's': /* string */
1697	case 'z': /* string or None */
1698#ifdef Py_USING_UNICODE
1699	case 'u': /* unicode string */
1700#endif
1701	case 't': /* buffer, read-only */
1702	case 'w': /* buffer, read-write */
1703		{
1704			(void) va_arg(*p_va, char **);
1705			if (*format == '#') {
1706				if (flags & FLAG_SIZE_T)
1707					(void) va_arg(*p_va, Py_ssize_t *);
1708				else
1709					(void) va_arg(*p_va, int *);
1710				format++;
1711			} else if ((c == 's' || c == 'z') && *format == '*') {
1712				format++;
1713			}
1714			break;
1715		}
1716
1717	/* object codes */
1718
1719	case 'S': /* string object */
1720#ifdef Py_USING_UNICODE
1721	case 'U': /* unicode string object */
1722#endif
1723		{
1724			(void) va_arg(*p_va, PyObject **);
1725			break;
1726		}
1727	
1728	case 'O': /* object */
1729		{
1730			if (*format == '!') {
1731				format++;
1732				(void) va_arg(*p_va, PyTypeObject*);
1733				(void) va_arg(*p_va, PyObject **);
1734			}
1735#if 0
1736/* I don't know what this is for */
1737			else if (*format == '?') {
1738				inquiry pred = va_arg(*p_va, inquiry);
1739				format++;
1740				if ((*pred)(arg)) {
1741					(void) va_arg(*p_va, PyObject **);
1742				}
1743			}
1744#endif
1745			else if (*format == '&') {
1746				typedef int (*converter)(PyObject *, void *);
1747				(void) va_arg(*p_va, converter);
1748				(void) va_arg(*p_va, void *);
1749				format++;
1750			}
1751			else {
1752				(void) va_arg(*p_va, PyObject **);
1753			}
1754			break;
1755		}
1756
1757	case '(':	/* bypass tuple, not handled at all previously */
1758		{
1759			char *msg;
1760			for (;;) {
1761				if (*format==')')
1762					break;
1763				if (IS_END_OF_FORMAT(*format))
1764					return "Unmatched left paren in format "
1765					       "string";
1766				msg = skipitem(&format, p_va, flags);
1767				if (msg)
1768					return msg;
1769			}
1770			format++;
1771			break;
1772		}
1773
1774	case ')':
1775		return "Unmatched right paren in format string";
1776
1777	default:
1778err:
1779		return "impossible<bad format char>";
1780	
1781	}
1782
1783	*p_format = format;
1784	return NULL;
1785}
1786
1787
1788int
1789PyArg_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, ...)
1790{
1791	Py_ssize_t i, l;
1792	PyObject **o;
1793	va_list vargs;
1794
1795#ifdef HAVE_STDARG_PROTOTYPES
1796	va_start(vargs, max);
1797#else
1798	va_start(vargs);
1799#endif
1800
1801	assert(min >= 0);
1802	assert(min <= max);
1803	if (!PyTuple_Check(args)) {
1804		PyErr_SetString(PyExc_SystemError,
1805		    "PyArg_UnpackTuple() argument list is not a tuple");
1806		return 0;
1807	}	
1808	l = PyTuple_GET_SIZE(args);
1809	if (l < min) {
1810		if (name != NULL)
1811			PyErr_Format(
1812			    PyExc_TypeError,
1813			    "%s expected %s%zd arguments, got %zd", 
1814			    name, (min == max ? "" : "at least "), min, l);
1815		else
1816			PyErr_Format(
1817			    PyExc_TypeError,
1818			    "unpacked tuple should have %s%zd elements,"
1819			    " but has %zd", 
1820			    (min == max ? "" : "at least "), min, l);
1821		va_end(vargs);
1822		return 0;
1823	}
1824	if (l > max) {
1825		if (name != NULL)
1826			PyErr_Format(
1827			    PyExc_TypeError,
1828			    "%s expected %s%zd arguments, got %zd", 
1829			    name, (min == max ? "" : "at most "), max, l);
1830		else
1831			PyErr_Format(
1832			    PyExc_TypeError,
1833			    "unpacked tuple should have %s%zd elements,"
1834			    " but has %zd", 
1835			    (min == max ? "" : "at most "), max, l);
1836		va_end(vargs);
1837		return 0;
1838	}
1839	for (i = 0; i < l; i++) {
1840		o = va_arg(vargs, PyObject **);
1841		*o = PyTuple_GET_ITEM(args, i);
1842	}
1843	va_end(vargs);
1844	return 1;
1845}
1846
1847
1848/* For type constructors that don't take keyword args
1849 *
1850 * Sets a TypeError and returns 0 if the kwds dict is 
1851 * not empty, returns 1 otherwise
1852 */
1853int
1854_PyArg_NoKeywords(const char *funcname, PyObject *kw)
1855{
1856	if (kw == NULL)
1857		return 1;
1858	if (!PyDict_CheckExact(kw)) {
1859		PyErr_BadInternalCall();
1860		return 0;
1861	}
1862	if (PyDict_Size(kw) == 0)
1863		return 1;
1864	
1865	PyErr_Format(PyExc_TypeError, "%s does not take keyword arguments", 
1866			funcname);
1867	return 0;
1868}
1869#ifdef __cplusplus
1870};
1871#endif