Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

getargs.c

Last change on this file was 391, checked in by dmik, 11 years ago
python: Merge vendor 2.7.6 to trunk.
Property svn:eol-style set to `native`
File size: 56.5 KB

Rev	Line
[2]	1
	2	/* New getargs implementation */
	3
	4	#include "Python.h"
	5
	6	#include <ctype.h>
	7
	8
	9	#ifdef __cplusplus
[391]	10	extern "C" {
[2]	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 ,
[391]	17	const char , char *, ...);
[2]	18	int PyArg_VaParseTupleAndKeywords(PyObject , PyObject ,
[391]	19	const char , char *, va_list);
[2]	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 );
[391]	40	static char convertitem(PyObject , const char *, va_list , int, int *,
[2]	41	char , size_t, PyObject *);
	42	static char converttuple(PyObject , const char *, va_list , int,
[391]	43	int , char , size_t, int, PyObject **);
[2]	44	static char convertsimple(PyObject , const char *, va_list , int, char *,
[391]	45	size_t, PyObject **);
[2]	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 ,
[391]	50	const char , char , va_list , int);
[2]	51	static char skipitem(const char , va_list , int);
	52
	53	int
	54	PyArg_Parse(PyObject args, const char format, ...)
	55	{
[391]	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;
[2]	63	}
	64
	65	int
	66	_PyArg_Parse_SizeT(PyObject args, char format, ...)
	67	{
[391]	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;
[2]	75	}
	76
	77
	78	int
	79	PyArg_ParseTuple(PyObject args, const char format, ...)
	80	{
[391]	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;
[2]	88	}
	89
	90	int
	91	_PyArg_ParseTuple_SizeT(PyObject args, char format, ...)
	92	{
[391]	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;
[2]	100	}
	101
	102
	103	int
	104	PyArg_VaParse(PyObject args, const char format, va_list va)
	105	{
[391]	106	va_list lva;
[2]	107
	108	#ifdef VA_LIST_IS_ARRAY
[391]	109	memcpy(lva, va, sizeof(va_list));
[2]	110	#else
	111	#ifdef __va_copy
[391]	112	__va_copy(lva, va);
[2]	113	#else
[391]	114	lva = va;
[2]	115	#endif
	116	#endif
	117
[391]	118	return vgetargs1(args, format, &lva, 0);
[2]	119	}
	120
	121	int
	122	_PyArg_VaParse_SizeT(PyObject args, char format, va_list va)
	123	{
[391]	124	va_list lva;
[2]	125
	126	#ifdef VA_LIST_IS_ARRAY
[391]	127	memcpy(lva, va, sizeof(va_list));
[2]	128	#else
	129	#ifdef __va_copy
[391]	130	__va_copy(lva, va);
[2]	131	#else
[391]	132	lva = va;
[2]	133	#endif
	134	#endif
	135
[391]	136	return vgetargs1(args, format, &lva, FLAG_SIZE_T);
[2]	137	}
	138
	139
	140	/* Handle cleanup of allocated memory in case of exception */
	141
[391]	142	#define GETARGS_CAPSULE_NAME_CLEANUP_PTR "getargs.cleanup_ptr"
	143	#define GETARGS_CAPSULE_NAME_CLEANUP_BUFFER "getargs.cleanup_buffer"
	144
[2]	145	static void
[391]	146	cleanup_ptr(PyObject *self)
[2]	147	{
[391]	148	void *ptr = PyCapsule_GetPointer(self, GETARGS_CAPSULE_NAME_CLEANUP_PTR);
	149	if (ptr) {
	150	PyMem_FREE(ptr);
	151	}
[2]	152	}
	153
	154	static void
[391]	155	cleanup_buffer(PyObject *self)
[2]	156	{
[391]	157	Py_buffer ptr = (Py_buffer )PyCapsule_GetPointer(self, GETARGS_CAPSULE_NAME_CLEANUP_BUFFER);
	158	if (ptr) {
	159	PyBuffer_Release(ptr);
	160	}
[2]	161	}
	162
	163	static int
[391]	164	addcleanup(void ptr, PyObject *freelist, PyCapsule_Destructor destr)
[2]	165	{
[391]	166	PyObject *cobj;
	167	const char *name;
	168
	169	if (!*freelist) {
	170	*freelist = PyList_New(0);
	171	if (!*freelist) {
	172	destr(ptr);
	173	return -1;
	174	}
	175	}
	176
	177	if (destr == cleanup_ptr) {
	178	name = GETARGS_CAPSULE_NAME_CLEANUP_PTR;
	179	} else if (destr == cleanup_buffer) {
	180	name = GETARGS_CAPSULE_NAME_CLEANUP_BUFFER;
	181	} else {
	182	return -1;
	183	}
	184	cobj = PyCapsule_New(ptr, name, destr);
	185	if (!cobj) {
	186	destr(ptr);
	187	return -1;
	188	}
	189	if (PyList_Append(*freelist, cobj)) {
[2]	190	Py_DECREF(cobj);
[391]	191	return -1;
	192	}
	193	Py_DECREF(cobj);
	194	return 0;
[2]	195	}
	196
	197	static int
	198	cleanreturn(int retval, PyObject *freelist)
	199	{
[391]	200	if (freelist && retval != 0) {
	201	/* We were successful, reset the destructors so that they
	202	don't get called. */
	203	Py_ssize_t len = PyList_GET_SIZE(freelist), i;
	204	for (i = 0; i < len; i++)
	205	PyCapsule_SetDestructor(PyList_GET_ITEM(freelist, i), NULL);
	206	}
	207	Py_XDECREF(freelist);
	208	return retval;
[2]	209	}
	210
	211
	212	static int
	213	vgetargs1(PyObject args, const char format, va_list *p_va, int flags)
	214	{
[391]	215	char msgbuf[256];
	216	int levels[32];
	217	const char *fname = NULL;
	218	const char *message = NULL;
	219	int min = -1;
	220	int max = 0;
	221	int level = 0;
	222	int endfmt = 0;
	223	const char *formatsave = format;
	224	Py_ssize_t i, len;
	225	char *msg;
	226	PyObject *freelist = NULL;
	227	int compat = flags & FLAG_COMPAT;
[2]	228
[391]	229	assert(compat \|\| (args != (PyObject*)NULL));
	230	flags = flags & ~FLAG_COMPAT;
[2]	231
[391]	232	while (endfmt == 0) {
	233	int c = *format++;
	234	switch (c) {
	235	case '(':
	236	if (level == 0)
	237	max++;
	238	level++;
	239	if (level >= 30)
	240	Py_FatalError("too many tuple nesting levels "
	241	"in argument format string");
	242	break;
	243	case ')':
	244	if (level == 0)
	245	Py_FatalError("excess ')' in getargs format");
	246	else
	247	level--;
	248	break;
	249	case '\0':
	250	endfmt = 1;
	251	break;
	252	case ':':
	253	fname = format;
	254	endfmt = 1;
	255	break;
	256	case ';':
	257	message = format;
	258	endfmt = 1;
	259	break;
	260	default:
	261	if (level == 0) {
	262	if (c == 'O')
	263	max++;
	264	else if (isalpha(Py_CHARMASK(c))) {
	265	if (c != 'e') /* skip encoded */
	266	max++;
	267	} else if (c == '\|')
	268	min = max;
	269	}
	270	break;
	271	}
	272	}
[2]	273
[391]	274	if (level != 0)
	275	Py_FatalError(/* '(' */ "missing ')' in getargs format");
	276
	277	if (min < 0)
	278	min = max;
	279
	280	format = formatsave;
	281
	282	if (compat) {
	283	if (max == 0) {
	284	if (args == NULL)
	285	return 1;
	286	PyOS_snprintf(msgbuf, sizeof(msgbuf),
	287	"%.200s%s takes no arguments",
	288	fname==NULL ? "function" : fname,
	289	fname==NULL ? "" : "()");
	290	PyErr_SetString(PyExc_TypeError, msgbuf);
	291	return 0;
	292	}
	293	else if (min == 1 && max == 1) {
	294	if (args == NULL) {
	295	PyOS_snprintf(msgbuf, sizeof(msgbuf),
	296	"%.200s%s takes at least one argument",
	297	fname==NULL ? "function" : fname,
	298	fname==NULL ? "" : "()");
	299	PyErr_SetString(PyExc_TypeError, msgbuf);
	300	return 0;
	301	}
	302	msg = convertitem(args, &format, p_va, flags, levels,
	303	msgbuf, sizeof(msgbuf), &freelist);
	304	if (msg == NULL)
	305	return cleanreturn(1, freelist);
	306	seterror(levels[0], msg, levels+1, fname, message);
	307	return cleanreturn(0, freelist);
	308	}
	309	else {
	310	PyErr_SetString(PyExc_SystemError,
	311	"old style getargs format uses new features");
	312	return 0;
	313	}
	314	}
	315
	316	if (!PyTuple_Check(args)) {
	317	PyErr_SetString(PyExc_SystemError,
	318	"new style getargs format but argument is not a tuple");
	319	return 0;
	320	}
	321
	322	len = PyTuple_GET_SIZE(args);
	323
	324	if (len < min \|\| max < len) {
	325	if (message == NULL) {
	326	PyOS_snprintf(msgbuf, sizeof(msgbuf),
	327	"%.150s%s takes %s %d argument%s "
	328	"(%ld given)",
	329	fname==NULL ? "function" : fname,
	330	fname==NULL ? "" : "()",
	331	min==max ? "exactly"
	332	: len < min ? "at least" : "at most",
	333	len < min ? min : max,
	334	(len < min ? min : max) == 1 ? "" : "s",
	335	Py_SAFE_DOWNCAST(len, Py_ssize_t, long));
	336	message = msgbuf;
	337	}
	338	PyErr_SetString(PyExc_TypeError, message);
	339	return 0;
	340	}
	341
	342	for (i = 0; i < len; i++) {
	343	if (*format == '\|')
	344	format++;
	345	msg = convertitem(PyTuple_GET_ITEM(args, i), &format, p_va,
	346	flags, levels, msgbuf,
	347	sizeof(msgbuf), &freelist);
	348	if (msg) {
	349	seterror(i+1, msg, levels, fname, msg);
	350	return cleanreturn(0, freelist);
	351	}
	352	}
	353
	354	if (format != '\0' && !isalpha(Py_CHARMASK(format)) &&
	355	*format != '(' &&
	356	format != '\|' && format != ':' && *format != ';') {
	357	PyErr_Format(PyExc_SystemError,
	358	"bad format string: %.200s", formatsave);
	359	return cleanreturn(0, freelist);
	360	}
	361
	362	return cleanreturn(1, freelist);
[2]	363	}
	364
	365
	366
	367	static void
	368	seterror(int iarg, const char msg, int levels, const char *fname,
	369	const char *message)
	370	{
[391]	371	char buf[512];
	372	int i;
	373	char *p = buf;
[2]	374
[391]	375	if (PyErr_Occurred())
	376	return;
	377	else if (message == NULL) {
	378	if (fname != NULL) {
	379	PyOS_snprintf(p, sizeof(buf), "%.200s() ", fname);
	380	p += strlen(p);
	381	}
	382	if (iarg != 0) {
	383	PyOS_snprintf(p, sizeof(buf) - (p - buf),
	384	"argument %d", iarg);
	385	i = 0;
	386	p += strlen(p);
	387	while (levels[i] > 0 && i < 32 && (int)(p-buf) < 220) {
	388	PyOS_snprintf(p, sizeof(buf) - (p - buf),
	389	", item %d", levels[i]-1);
	390	p += strlen(p);
	391	i++;
	392	}
	393	}
	394	else {
	395	PyOS_snprintf(p, sizeof(buf) - (p - buf), "argument");
	396	p += strlen(p);
	397	}
	398	PyOS_snprintf(p, sizeof(buf) - (p - buf), " %.256s", msg);
	399	message = buf;
	400	}
	401	PyErr_SetString(PyExc_TypeError, message);
[2]	402	}
	403
	404
	405	/* Convert a tuple argument.
	406	On entry, *p_format points to the character _after_ the opening '('.
	407	On successful exit, *p_format points to the closing ')'.
	408	If successful:
	409	p_format and p_va are updated,
	410	levels and msgbuf are untouched,
	411	and NULL is returned.
	412	If the argument is invalid:
	413	*p_format is unchanged,
	414	*p_va is undefined,
	415	*levels is a 0-terminated list of item numbers,
	416	*msgbuf contains an error message, whose format is:
[391]	417	"must be <typename1>, not <typename2>", where:
	418	<typename1> is the name of the expected type, and
	419	<typename2> is the name of the actual type,
[2]	420	and msgbuf is returned.
	421	*/
	422
	423	static char *
	424	converttuple(PyObject arg, const char p_format, va_list p_va, int flags,
[391]	425	int levels, char msgbuf, size_t bufsize, int toplevel,
[2]	426	PyObject **freelist)
	427	{
[391]	428	int level = 0;
	429	int n = 0;
	430	const char format = p_format;
	431	int i;
[2]	432
[391]	433	for (;;) {
	434	int c = *format++;
	435	if (c == '(') {
	436	if (level == 0)
	437	n++;
	438	level++;
	439	}
	440	else if (c == ')') {
	441	if (level == 0)
	442	break;
	443	level--;
	444	}
	445	else if (c == ':' \|\| c == ';' \|\| c == '\0')
	446	break;
	447	else if (level == 0 && isalpha(Py_CHARMASK(c)))
	448	n++;
	449	}
[2]	450
[391]	451	if (!PySequence_Check(arg) \|\| PyString_Check(arg)) {
	452	levels[0] = 0;
	453	PyOS_snprintf(msgbuf, bufsize,
	454	toplevel ? "expected %d arguments, not %.50s" :
	455	"must be %d-item sequence, not %.50s",
	456	n,
	457	arg == Py_None ? "None" : arg->ob_type->tp_name);
	458	return msgbuf;
	459	}
	460
	461	if ((i = PySequence_Size(arg)) != n) {
	462	levels[0] = 0;
	463	PyOS_snprintf(msgbuf, bufsize,
	464	toplevel ? "expected %d arguments, not %d" :
	465	"must be sequence of length %d, not %d",
	466	n, i);
	467	return msgbuf;
	468	}
	469
	470	format = *p_format;
	471	for (i = 0; i < n; i++) {
	472	char *msg;
	473	PyObject *item;
	474	item = PySequence_GetItem(arg, i);
	475	if (item == NULL) {
	476	PyErr_Clear();
	477	levels[0] = i+1;
	478	levels[1] = 0;
	479	strncpy(msgbuf, "is not retrievable", bufsize);
	480	return msgbuf;
	481	}
	482	msg = convertitem(item, &format, p_va, flags, levels+1,
	483	msgbuf, bufsize, freelist);
	484	/* PySequence_GetItem calls tp->sq_item, which INCREFs */
	485	Py_XDECREF(item);
	486	if (msg != NULL) {
	487	levels[0] = i+1;
	488	return msg;
	489	}
	490	}
	491
	492	*p_format = format;
	493	return NULL;
[2]	494	}
	495
	496
	497	/* Convert a single item. */
	498
	499	static char *
	500	convertitem(PyObject arg, const char p_format, va_list p_va, int flags,
	501	int levels, char msgbuf, size_t bufsize, PyObject **freelist)
	502	{
[391]	503	char *msg;
	504	const char format = p_format;
	505
	506	if (format == '(' / ')' */) {
	507	format++;
	508	msg = converttuple(arg, &format, p_va, flags, levels, msgbuf,
	509	bufsize, 0, freelist);
	510	if (msg == NULL)
	511	format++;
	512	}
	513	else {
	514	msg = convertsimple(arg, &format, p_va, flags,
	515	msgbuf, bufsize, freelist);
	516	if (msg != NULL)
	517	levels[0] = 0;
	518	}
	519	if (msg == NULL)
	520	*p_format = format;
	521	return msg;
[2]	522	}
	523
	524
	525
	526	#define UNICODE_DEFAULT_ENCODING(arg) \
[391]	527	_PyUnicode_AsDefaultEncodedString(arg, NULL)
[2]	528
	529	/* Format an error message generated by convertsimple(). */
	530
	531	static char *
	532	converterr(const char expected, PyObject arg, char *msgbuf, size_t bufsize)
	533	{
[391]	534	assert(expected != NULL);
	535	assert(arg != NULL);
	536	PyOS_snprintf(msgbuf, bufsize,
	537	"must be %.50s, not %.50s", expected,
	538	arg == Py_None ? "None" : arg->ob_type->tp_name);
	539	return msgbuf;
[2]	540	}
	541
	542	#define CONV_UNICODE "(unicode conversion error)"
	543
	544	/* explicitly check for float arguments when integers are expected. For now
	545	* signal a warning. Returns true if an exception was raised. */
	546	static int
[391]	547	float_argument_warning(PyObject *arg)
	548	{
	549	if (PyFloat_Check(arg) &&
	550	PyErr_Warn(PyExc_DeprecationWarning,
	551	"integer argument expected, got float" ))
	552	return 1;
	553	else
	554	return 0;
	555	}
	556
	557	/* explicitly check for float arguments when integers are expected. Raises
	558	TypeError and returns true for float arguments. */
	559	static int
[2]	560	float_argument_error(PyObject *arg)
	561	{
[391]	562	if (PyFloat_Check(arg)) {
	563	PyErr_SetString(PyExc_TypeError,
	564	"integer argument expected, got float");
	565	return 1;
	566	}
	567	else
	568	return 0;
[2]	569	}
	570
	571	/* Convert a non-tuple argument. Return NULL if conversion went OK,
	572	or a string with a message describing the failure. The message is
	573	formatted as "must be <desired type>, not <actual type>".
	574	When failing, an exception may or may not have been raised.
	575	Don't call if a tuple is expected.
	576
	577	When you add new format codes, please don't forget poor skipitem() below.
	578	*/
	579
	580	static char *
	581	convertsimple(PyObject arg, const char p_format, va_list p_va, int flags,
	582	char msgbuf, size_t bufsize, PyObject *freelist)
	583	{
[391]	584	/* For # codes */
	585	#define FETCH_SIZE int q=NULL;Py_ssize_t q2=NULL;\
	586	if (flags & FLAG_SIZE_T) q2=va_arg(p_va, Py_ssize_t); \
	587	else q=va_arg(p_va, int);
	588	#define STORE_SIZE(s) \
	589	if (flags & FLAG_SIZE_T) \
	590	*q2=s; \
	591	else { \
	592	if (INT_MAX < s) { \
	593	PyErr_SetString(PyExc_OverflowError, \
	594	"size does not fit in an int"); \
	595	return converterr("", arg, msgbuf, bufsize); \
	596	} \
	597	*q=s; \
	598	}
[2]	599	#define BUFFER_LEN ((flags & FLAG_SIZE_T) ? q2:q)
	600
[391]	601	const char format = p_format;
	602	char c = *format++;
[2]	603	#ifdef Py_USING_UNICODE
[391]	604	PyObject *uarg;
[2]	605	#endif
	606
[391]	607	switch (c) {
[2]	608
[391]	609	case 'b': { /* unsigned byte -- very short int */
	610	char p = va_arg(p_va, char *);
	611	long ival;
	612	if (float_argument_error(arg))
	613	return converterr("integer<b>", arg, msgbuf, bufsize);
	614	ival = PyInt_AsLong(arg);
	615	if (ival == -1 && PyErr_Occurred())
	616	return converterr("integer<b>", arg, msgbuf, bufsize);
	617	else if (ival < 0) {
	618	PyErr_SetString(PyExc_OverflowError,
	619	"unsigned byte integer is less than minimum");
	620	return converterr("integer<b>", arg, msgbuf, bufsize);
	621	}
	622	else if (ival > UCHAR_MAX) {
	623	PyErr_SetString(PyExc_OverflowError,
	624	"unsigned byte integer is greater than maximum");
	625	return converterr("integer<b>", arg, msgbuf, bufsize);
	626	}
	627	else
	628	*p = (unsigned char) ival;
	629	break;
	630	}
	631
	632	case 'B': {/* byte sized bitfield - both signed and unsigned
	633	values allowed */
	634	char p = va_arg(p_va, char *);
	635	long ival;
	636	if (float_argument_error(arg))
	637	return converterr("integer<B>", arg, msgbuf, bufsize);
	638	ival = PyInt_AsUnsignedLongMask(arg);
	639	if (ival == -1 && PyErr_Occurred())
	640	return converterr("integer<B>", arg, msgbuf, bufsize);
	641	else
	642	*p = (unsigned char) ival;
	643	break;
	644	}
	645
	646	case 'h': {/* signed short int */
	647	short p = va_arg(p_va, short *);
	648	long ival;
	649	if (float_argument_error(arg))
	650	return converterr("integer<h>", arg, msgbuf, bufsize);
	651	ival = PyInt_AsLong(arg);
	652	if (ival == -1 && PyErr_Occurred())
	653	return converterr("integer<h>", arg, msgbuf, bufsize);
	654	else if (ival < SHRT_MIN) {
	655	PyErr_SetString(PyExc_OverflowError,
	656	"signed short integer is less than minimum");
	657	return converterr("integer<h>", arg, msgbuf, bufsize);
	658	}
	659	else if (ival > SHRT_MAX) {
	660	PyErr_SetString(PyExc_OverflowError,
	661	"signed short integer is greater than maximum");
	662	return converterr("integer<h>", arg, msgbuf, bufsize);
	663	}
	664	else
	665	*p = (short) ival;
	666	break;
	667	}
	668
	669	case 'H': { /* short int sized bitfield, both signed and
	670	unsigned allowed */
	671	unsigned short p = va_arg(p_va, unsigned short *);
	672	long ival;
	673	if (float_argument_error(arg))
	674	return converterr("integer<H>", arg, msgbuf, bufsize);
	675	ival = PyInt_AsUnsignedLongMask(arg);
	676	if (ival == -1 && PyErr_Occurred())
	677	return converterr("integer<H>", arg, msgbuf, bufsize);
	678	else
	679	*p = (unsigned short) ival;
	680	break;
	681	}
	682
	683	case 'i': {/* signed int */
	684	int p = va_arg(p_va, int *);
	685	long ival;
	686	if (float_argument_error(arg))
	687	return converterr("integer<i>", arg, msgbuf, bufsize);
	688	ival = PyInt_AsLong(arg);
	689	if (ival == -1 && PyErr_Occurred())
	690	return converterr("integer<i>", arg, msgbuf, bufsize);
	691	else if (ival > INT_MAX) {
	692	PyErr_SetString(PyExc_OverflowError,
	693	"signed integer is greater than maximum");
	694	return converterr("integer<i>", arg, msgbuf, bufsize);
	695	}
	696	else if (ival < INT_MIN) {
	697	PyErr_SetString(PyExc_OverflowError,
	698	"signed integer is less than minimum");
	699	return converterr("integer<i>", arg, msgbuf, bufsize);
	700	}
	701	else
	702	*p = ival;
	703	break;
	704	}
	705
	706	case 'I': { /* int sized bitfield, both signed and
	707	unsigned allowed */
	708	unsigned int p = va_arg(p_va, unsigned int *);
	709	unsigned int ival;
	710	if (float_argument_error(arg))
	711	return converterr("integer<I>", arg, msgbuf, bufsize);
	712	ival = (unsigned int)PyInt_AsUnsignedLongMask(arg);
	713	if (ival == (unsigned int)-1 && PyErr_Occurred())
	714	return converterr("integer<I>", arg, msgbuf, bufsize);
	715	else
	716	*p = ival;
	717	break;
	718	}
	719
	720	case 'n': /* Py_ssize_t */
[2]	721	#if SIZEOF_SIZE_T != SIZEOF_LONG
[391]	722	{
	723	Py_ssize_t p = va_arg(p_va, Py_ssize_t *);
	724	Py_ssize_t ival;
	725	if (float_argument_error(arg))
	726	return converterr("integer<n>", arg, msgbuf, bufsize);
	727	ival = PyInt_AsSsize_t(arg);
	728	if (ival == -1 && PyErr_Occurred())
	729	return converterr("integer<n>", arg, msgbuf, bufsize);
	730	*p = ival;
	731	break;
	732	}
[2]	733	#endif
[391]	734	/* Fall through from 'n' to 'l' if Py_ssize_t is int */
	735	case 'l': {/* long int */
	736	long p = va_arg(p_va, long *);
	737	long ival;
	738	if (float_argument_error(arg))
	739	return converterr("integer<l>", arg, msgbuf, bufsize);
	740	ival = PyInt_AsLong(arg);
	741	if (ival == -1 && PyErr_Occurred())
	742	return converterr("integer<l>", arg, msgbuf, bufsize);
	743	else
	744	*p = ival;
	745	break;
	746	}
[2]	747
[391]	748	case 'k': { /* long sized bitfield */
	749	unsigned long p = va_arg(p_va, unsigned long *);
	750	unsigned long ival;
	751	if (PyInt_Check(arg))
	752	ival = PyInt_AsUnsignedLongMask(arg);
	753	else if (PyLong_Check(arg))
	754	ival = PyLong_AsUnsignedLongMask(arg);
	755	else
	756	return converterr("integer<k>", arg, msgbuf, bufsize);
	757	*p = ival;
	758	break;
	759	}
	760
[2]	761	#ifdef HAVE_LONG_LONG
[391]	762	case 'L': {/* PY_LONG_LONG */
	763	PY_LONG_LONG p = va_arg( p_va, PY_LONG_LONG * );
	764	PY_LONG_LONG ival;
	765	if (float_argument_warning(arg))
	766	return converterr("long<L>", arg, msgbuf, bufsize);
	767	ival = PyLong_AsLongLong(arg);
	768	if (ival == (PY_LONG_LONG)-1 && PyErr_Occurred() ) {
	769	return converterr("long<L>", arg, msgbuf, bufsize);
	770	} else {
	771	*p = ival;
	772	}
	773	break;
	774	}
[2]	775
[391]	776	case 'K': { /* long long sized bitfield */
	777	unsigned PY_LONG_LONG p = va_arg(p_va, unsigned PY_LONG_LONG *);
	778	unsigned PY_LONG_LONG ival;
	779	if (PyInt_Check(arg))
	780	ival = PyInt_AsUnsignedLongMask(arg);
	781	else if (PyLong_Check(arg))
	782	ival = PyLong_AsUnsignedLongLongMask(arg);
	783	else
	784	return converterr("integer<K>", arg, msgbuf, bufsize);
	785	*p = ival;
	786	break;
	787	}
[2]	788	#endif
[391]	789
	790	case 'f': {/* float */
	791	float p = va_arg(p_va, float *);
	792	double dval = PyFloat_AsDouble(arg);
	793	if (PyErr_Occurred())
	794	return converterr("float<f>", arg, msgbuf, bufsize);
	795	else
	796	*p = (float) dval;
	797	break;
	798	}
	799
	800	case 'd': {/* double */
	801	double p = va_arg(p_va, double *);
	802	double dval = PyFloat_AsDouble(arg);
	803	if (PyErr_Occurred())
	804	return converterr("float<d>", arg, msgbuf, bufsize);
	805	else
	806	*p = dval;
	807	break;
	808	}
	809
[2]	810	#ifndef WITHOUT_COMPLEX
[391]	811	case 'D': {/* complex double */
	812	Py_complex p = va_arg(p_va, Py_complex *);
	813	Py_complex cval;
	814	cval = PyComplex_AsCComplex(arg);
	815	if (PyErr_Occurred())
	816	return converterr("complex<D>", arg, msgbuf, bufsize);
	817	else
	818	*p = cval;
	819	break;
	820	}
[2]	821	#endif /* WITHOUT_COMPLEX */
	822
[391]	823	case 'c': {/* char */
	824	char p = va_arg(p_va, char *);
	825	if (PyString_Check(arg) && PyString_Size(arg) == 1)
	826	*p = PyString_AS_STRING(arg)[0];
	827	else
	828	return converterr("char", arg, msgbuf, bufsize);
	829	break;
	830	}
	831
	832	case 's': {/* string */
	833	if (format == '') {
	834	Py_buffer p = (Py_buffer )va_arg(p_va, Py_buffer );
	835
	836	if (PyString_Check(arg)) {
	837	PyBuffer_FillInfo(p, arg,
	838	PyString_AS_STRING(arg), PyString_GET_SIZE(arg),
	839	1, 0);
	840	}
[2]	841	#ifdef Py_USING_UNICODE
[391]	842	else if (PyUnicode_Check(arg)) {
	843	uarg = UNICODE_DEFAULT_ENCODING(arg);
	844	if (uarg == NULL)
	845	return converterr(CONV_UNICODE,
	846	arg, msgbuf, bufsize);
	847	PyBuffer_FillInfo(p, arg,
	848	PyString_AS_STRING(uarg), PyString_GET_SIZE(uarg),
	849	1, 0);
	850	}
[2]	851	#endif
[391]	852	else { /* any buffer-like object */
	853	char *buf;
	854	if (getbuffer(arg, p, &buf) < 0)
	855	return converterr(buf, arg, msgbuf, bufsize);
	856	}
	857	if (addcleanup(p, freelist, cleanup_buffer)) {
	858	return converterr(
	859	"(cleanup problem)",
	860	arg, msgbuf, bufsize);
	861	}
	862	format++;
	863	} else if (*format == '#') {
	864	void p = (void )va_arg(p_va, char *);
	865	FETCH_SIZE;
	866
	867	if (PyString_Check(arg)) {
	868	*p = PyString_AS_STRING(arg);
	869	STORE_SIZE(PyString_GET_SIZE(arg));
	870	}
[2]	871	#ifdef Py_USING_UNICODE
[391]	872	else if (PyUnicode_Check(arg)) {
	873	uarg = UNICODE_DEFAULT_ENCODING(arg);
	874	if (uarg == NULL)
	875	return converterr(CONV_UNICODE,
	876	arg, msgbuf, bufsize);
	877	*p = PyString_AS_STRING(uarg);
	878	STORE_SIZE(PyString_GET_SIZE(uarg));
	879	}
[2]	880	#endif
[391]	881	else { /* any buffer-like object */
	882	char *buf;
	883	Py_ssize_t count = convertbuffer(arg, p, &buf);
	884	if (count < 0)
	885	return converterr(buf, arg, msgbuf, bufsize);
	886	STORE_SIZE(count);
	887	}
	888	format++;
	889	} else {
	890	char *p = va_arg(p_va, char **);
	891
	892	if (PyString_Check(arg))
	893	*p = PyString_AS_STRING(arg);
[2]	894	#ifdef Py_USING_UNICODE
[391]	895	else if (PyUnicode_Check(arg)) {
	896	uarg = UNICODE_DEFAULT_ENCODING(arg);
	897	if (uarg == NULL)
	898	return converterr(CONV_UNICODE,
	899	arg, msgbuf, bufsize);
	900	*p = PyString_AS_STRING(uarg);
	901	}
[2]	902	#endif
[391]	903	else
	904	return converterr("string", arg, msgbuf, bufsize);
	905	if ((Py_ssize_t)strlen(*p) != PyString_Size(arg))
	906	return converterr("string without null bytes",
	907	arg, msgbuf, bufsize);
	908	}
	909	break;
	910	}
[2]	911
[391]	912	case 'z': {/* string, may be NULL (None) */
	913	if (format == '') {
	914	Py_buffer p = (Py_buffer )va_arg(p_va, Py_buffer );
[2]	915
[391]	916	if (arg == Py_None)
	917	PyBuffer_FillInfo(p, NULL, NULL, 0, 1, 0);
	918	else if (PyString_Check(arg)) {
	919	PyBuffer_FillInfo(p, arg,
	920	PyString_AS_STRING(arg), PyString_GET_SIZE(arg),
	921	1, 0);
	922	}
[2]	923	#ifdef Py_USING_UNICODE
[391]	924	else if (PyUnicode_Check(arg)) {
	925	uarg = UNICODE_DEFAULT_ENCODING(arg);
	926	if (uarg == NULL)
	927	return converterr(CONV_UNICODE,
	928	arg, msgbuf, bufsize);
	929	PyBuffer_FillInfo(p, arg,
	930	PyString_AS_STRING(uarg), PyString_GET_SIZE(uarg),
	931	1, 0);
	932	}
[2]	933	#endif
[391]	934	else { /* any buffer-like object */
	935	char *buf;
	936	if (getbuffer(arg, p, &buf) < 0)
	937	return converterr(buf, arg, msgbuf, bufsize);
	938	}
	939	if (addcleanup(p, freelist, cleanup_buffer)) {
	940	return converterr(
	941	"(cleanup problem)",
	942	arg, msgbuf, bufsize);
	943	}
	944	format++;
	945	} else if (format == '#') { / any buffer-like object */
	946	void p = (void )va_arg(p_va, char *);
	947	FETCH_SIZE;
	948
	949	if (arg == Py_None) {
	950	*p = 0;
	951	STORE_SIZE(0);
	952	}
	953	else if (PyString_Check(arg)) {
	954	*p = PyString_AS_STRING(arg);
	955	STORE_SIZE(PyString_GET_SIZE(arg));
	956	}
[2]	957	#ifdef Py_USING_UNICODE
[391]	958	else if (PyUnicode_Check(arg)) {
	959	uarg = UNICODE_DEFAULT_ENCODING(arg);
	960	if (uarg == NULL)
	961	return converterr(CONV_UNICODE,
	962	arg, msgbuf, bufsize);
	963	*p = PyString_AS_STRING(uarg);
	964	STORE_SIZE(PyString_GET_SIZE(uarg));
	965	}
[2]	966	#endif
[391]	967	else { /* any buffer-like object */
	968	char *buf;
	969	Py_ssize_t count = convertbuffer(arg, p, &buf);
	970	if (count < 0)
	971	return converterr(buf, arg, msgbuf, bufsize);
	972	STORE_SIZE(count);
	973	}
	974	format++;
	975	} else {
	976	char *p = va_arg(p_va, char **);
	977
	978	if (arg == Py_None)
	979	*p = 0;
	980	else if (PyString_Check(arg))
	981	*p = PyString_AS_STRING(arg);
[2]	982	#ifdef Py_USING_UNICODE
[391]	983	else if (PyUnicode_Check(arg)) {
	984	uarg = UNICODE_DEFAULT_ENCODING(arg);
	985	if (uarg == NULL)
	986	return converterr(CONV_UNICODE,
	987	arg, msgbuf, bufsize);
	988	*p = PyString_AS_STRING(uarg);
	989	}
[2]	990	#endif
[391]	991	else
	992	return converterr("string or None",
	993	arg, msgbuf, bufsize);
	994	if (*format == '#') {
	995	FETCH_SIZE;
	996	assert(0); /* XXX redundant with if-case */
	997	if (arg == Py_None) {
	998	STORE_SIZE(0);
	999	} else {
	1000	STORE_SIZE(PyString_Size(arg));
	1001	}
	1002	format++;
	1003	}
	1004	else if (*p != NULL &&
	1005	(Py_ssize_t)strlen(*p) != PyString_Size(arg))
	1006	return converterr(
	1007	"string without null bytes or None",
	1008	arg, msgbuf, bufsize);
	1009	}
	1010	break;
	1011	}
[2]	1012
[391]	1013	case 'e': {/* encoded string */
	1014	char **buffer;
	1015	const char *encoding;
	1016	PyObject *s;
	1017	Py_ssize_t size;
	1018	int recode_strings;
	1019
	1020	/* Get 'e' parameter: the encoding name */
	1021	encoding = (const char )va_arg(p_va, const char *);
[2]	1022	#ifdef Py_USING_UNICODE
[391]	1023	if (encoding == NULL)
	1024	encoding = PyUnicode_GetDefaultEncoding();
[2]	1025	#endif
[391]	1026
	1027	/* Get output buffer parameter:
	1028	's' (recode all objects via Unicode) or
	1029	't' (only recode non-string objects)
	1030	*/
	1031	if (*format == 's')
	1032	recode_strings = 1;
	1033	else if (*format == 't')
	1034	recode_strings = 0;
	1035	else
	1036	return converterr(
	1037	"(unknown parser marker combination)",
	1038	arg, msgbuf, bufsize);
	1039	buffer = (char *)va_arg(p_va, char **);
	1040	format++;
	1041	if (buffer == NULL)
	1042	return converterr("(buffer is NULL)",
	1043	arg, msgbuf, bufsize);
	1044
	1045	/* Encode object */
	1046	if (!recode_strings && PyString_Check(arg)) {
	1047	s = arg;
	1048	Py_INCREF(s);
	1049	}
	1050	else {
[2]	1051	#ifdef Py_USING_UNICODE
[391]	1052	PyObject *u;
[2]	1053
[391]	1054	/* Convert object to Unicode */
	1055	u = PyUnicode_FromObject(arg);
	1056	if (u == NULL)
	1057	return converterr(
	1058	"string or unicode or text buffer",
	1059	arg, msgbuf, bufsize);
	1060
	1061	/* Encode object; use default error handling */
	1062	s = PyUnicode_AsEncodedString(u,
	1063	encoding,
	1064	NULL);
	1065	Py_DECREF(u);
	1066	if (s == NULL)
	1067	return converterr("(encoding failed)",
	1068	arg, msgbuf, bufsize);
	1069	if (!PyString_Check(s)) {
	1070	Py_DECREF(s);
	1071	return converterr(
	1072	"(encoder failed to return a string)",
	1073	arg, msgbuf, bufsize);
	1074	}
[2]	1075	#else
[391]	1076	return converterr("string<e>", arg, msgbuf, bufsize);
[2]	1077	#endif
[391]	1078	}
	1079	size = PyString_GET_SIZE(s);
[2]	1080
[391]	1081	/* Write output; output is guaranteed to be 0-terminated */
	1082	if (*format == '#') {
	1083	/* Using buffer length parameter '#':
[2]	1084
[391]	1085	- if *buffer is NULL, a new buffer of the
	1086	needed size is allocated and the data
	1087	copied into it; *buffer is updated to point
	1088	to the new buffer; the caller is
	1089	responsible for PyMem_Free()ing it after
	1090	usage
[2]	1091
[391]	1092	- if *buffer is not NULL, the data is
	1093	copied to buffer; buffer_len has to be
	1094	set to the size of the buffer on input;
	1095	buffer overflow is signalled with an error;
	1096	buffer has to provide enough room for the
	1097	encoded string plus the trailing 0-byte
[2]	1098
[391]	1099	- in both cases, *buffer_len is updated to
	1100	the size of the buffer /excluding/ the
	1101	trailing 0-byte
[2]	1102
[391]	1103	*/
	1104	FETCH_SIZE;
[2]	1105
[391]	1106	format++;
	1107	if (q == NULL && q2 == NULL) {
	1108	Py_DECREF(s);
	1109	return converterr(
	1110	"(buffer_len is NULL)",
	1111	arg, msgbuf, bufsize);
	1112	}
	1113	if (*buffer == NULL) {
	1114	*buffer = PyMem_NEW(char, size + 1);
	1115	if (*buffer == NULL) {
	1116	Py_DECREF(s);
	1117	return converterr(
	1118	"(memory error)",
	1119	arg, msgbuf, bufsize);
	1120	}
	1121	if (addcleanup(*buffer, freelist, cleanup_ptr)) {
	1122	Py_DECREF(s);
	1123	return converterr(
	1124	"(cleanup problem)",
	1125	arg, msgbuf, bufsize);
	1126	}
	1127	} else {
	1128	if (size + 1 > BUFFER_LEN) {
	1129	Py_DECREF(s);
	1130	return converterr(
	1131	"(buffer overflow)",
	1132	arg, msgbuf, bufsize);
	1133	}
	1134	}
	1135	memcpy(*buffer,
	1136	PyString_AS_STRING(s),
	1137	size + 1);
	1138	STORE_SIZE(size);
	1139	} else {
	1140	/* Using a 0-terminated buffer:
	1141
	1142	- the encoded string has to be 0-terminated
	1143	for this variant to work; if it is not, an
	1144	error raised
	1145
	1146	- a new buffer of the needed size is
	1147	allocated and the data copied into it;
	1148	*buffer is updated to point to the new
	1149	buffer; the caller is responsible for
	1150	PyMem_Free()ing it after usage
	1151
	1152	*/
	1153	if ((Py_ssize_t)strlen(PyString_AS_STRING(s))
	1154	!= size) {
	1155	Py_DECREF(s);
	1156	return converterr(
	1157	"encoded string without NULL bytes",
	1158	arg, msgbuf, bufsize);
	1159	}
	1160	*buffer = PyMem_NEW(char, size + 1);
	1161	if (*buffer == NULL) {
	1162	Py_DECREF(s);
	1163	return converterr("(memory error)",
	1164	arg, msgbuf, bufsize);
	1165	}
	1166	if (addcleanup(*buffer, freelist, cleanup_ptr)) {
	1167	Py_DECREF(s);
	1168	return converterr("(cleanup problem)",
	1169	arg, msgbuf, bufsize);
	1170	}
	1171	memcpy(*buffer,
	1172	PyString_AS_STRING(s),
	1173	size + 1);
	1174	}
	1175	Py_DECREF(s);
	1176	break;
	1177	}
	1178
[2]	1179	#ifdef Py_USING_UNICODE
[391]	1180	case 'u': {/* raw unicode buffer (Py_UNICODE ) /
	1181	if (format == '#') { / any buffer-like object */
	1182	void p = (void )va_arg(p_va, char *);
	1183	FETCH_SIZE;
	1184	if (PyUnicode_Check(arg)) {
	1185	*p = PyUnicode_AS_UNICODE(arg);
	1186	STORE_SIZE(PyUnicode_GET_SIZE(arg));
	1187	}
	1188	else {
	1189	return converterr("cannot convert raw buffers",
	1190	arg, msgbuf, bufsize);
	1191	}
	1192	format++;
	1193	} else {
	1194	Py_UNICODE *p = va_arg(p_va, Py_UNICODE **);
	1195	if (PyUnicode_Check(arg))
	1196	*p = PyUnicode_AS_UNICODE(arg);
	1197	else
	1198	return converterr("unicode", arg, msgbuf, bufsize);
	1199	}
	1200	break;
	1201	}
[2]	1202	#endif
	1203
[391]	1204	case 'S': { /* string object */
	1205	PyObject *p = va_arg(p_va, PyObject **);
	1206	if (PyString_Check(arg))
	1207	*p = arg;
	1208	else
	1209	return converterr("string", arg, msgbuf, bufsize);
	1210	break;
	1211	}
	1212
[2]	1213	#ifdef Py_USING_UNICODE
[391]	1214	case 'U': { /* Unicode object */
	1215	PyObject *p = va_arg(p_va, PyObject **);
	1216	if (PyUnicode_Check(arg))
	1217	*p = arg;
	1218	else
	1219	return converterr("unicode", arg, msgbuf, bufsize);
	1220	break;
	1221	}
[2]	1222	#endif
	1223
[391]	1224	case 'O': { /* object */
	1225	PyTypeObject *type;
	1226	PyObject **p;
	1227	if (*format == '!') {
	1228	type = va_arg(p_va, PyTypeObject);
	1229	p = va_arg(p_va, PyObject *);
	1230	format++;
	1231	if (PyType_IsSubtype(arg->ob_type, type))
	1232	*p = arg;
	1233	else
	1234	return converterr(type->tp_name, arg, msgbuf, bufsize);
[2]	1235
[391]	1236	}
	1237	else if (*format == '?') {
	1238	inquiry pred = va_arg(*p_va, inquiry);
	1239	p = va_arg(p_va, PyObject *);
	1240	format++;
	1241	if ((*pred)(arg))
	1242	*p = arg;
	1243	else
	1244	return converterr("(unspecified)",
	1245	arg, msgbuf, bufsize);
[2]	1246
[391]	1247	}
	1248	else if (*format == '&') {
	1249	typedef int (converter)(PyObject , void *);
	1250	converter convert = va_arg(*p_va, converter);
	1251	void addr = va_arg(p_va, void *);
	1252	format++;
	1253	if (! (*convert)(arg, addr))
	1254	return converterr("(unspecified)",
	1255	arg, msgbuf, bufsize);
	1256	}
	1257	else {
	1258	p = va_arg(p_va, PyObject *);
	1259	*p = arg;
	1260	}
	1261	break;
	1262	}
[2]	1263
	1264
[391]	1265	case 'w': { /* memory buffer, read-write access */
	1266	void *p = va_arg(p_va, void **);
	1267	void *res;
	1268	PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
	1269	Py_ssize_t count;
[2]	1270
[391]	1271	if (pb && pb->bf_releasebuffer && format != '')
	1272	/* Buffer must be released, yet caller does not use
	1273	the Py_buffer protocol. */
	1274	return converterr("pinned buffer", arg, msgbuf, bufsize);
[2]	1275
[391]	1276	if (pb && pb->bf_getbuffer && format == '') {
	1277	/* Caller is interested in Py_buffer, and the object
	1278	supports it directly. */
	1279	format++;
	1280	if (pb->bf_getbuffer(arg, (Py_buffer*)p, PyBUF_WRITABLE) < 0) {
	1281	PyErr_Clear();
	1282	return converterr("read-write buffer", arg, msgbuf, bufsize);
	1283	}
	1284	if (addcleanup(p, freelist, cleanup_buffer)) {
	1285	return converterr(
	1286	"(cleanup problem)",
	1287	arg, msgbuf, bufsize);
	1288	}
	1289	if (!PyBuffer_IsContiguous((Py_buffer*)p, 'C'))
	1290	return converterr("contiguous buffer", arg, msgbuf, bufsize);
	1291	break;
	1292	}
[2]	1293
[391]	1294	if (pb == NULL \|\|
	1295	pb->bf_getwritebuffer == NULL \|\|
	1296	pb->bf_getsegcount == NULL)
	1297	return converterr("read-write buffer", arg, msgbuf, bufsize);
	1298	if ((*pb->bf_getsegcount)(arg, NULL) != 1)
	1299	return converterr("single-segment read-write buffer",
	1300	arg, msgbuf, bufsize);
	1301	if ((count = pb->bf_getwritebuffer(arg, 0, &res)) < 0)
	1302	return converterr("(unspecified)", arg, msgbuf, bufsize);
	1303	if (format == '') {
	1304	PyBuffer_FillInfo((Py_buffer*)p, arg, res, count, 1, 0);
	1305	format++;
	1306	}
	1307	else {
	1308	*p = res;
	1309	if (*format == '#') {
	1310	FETCH_SIZE;
	1311	STORE_SIZE(count);
	1312	format++;
	1313	}
	1314	}
	1315	break;
	1316	}
	1317
	1318	case 't': { /* 8-bit character buffer, read-only access */
	1319	char *p = va_arg(p_va, char **);
	1320	PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
	1321	Py_ssize_t count;
	1322
	1323	if (*format++ != '#')
	1324	return converterr(
	1325	"invalid use of 't' format character",
	1326	arg, msgbuf, bufsize);
	1327	if (!PyType_HasFeature(arg->ob_type,
	1328	Py_TPFLAGS_HAVE_GETCHARBUFFER) \|\|
	1329	pb == NULL \|\| pb->bf_getcharbuffer == NULL \|\|
	1330	pb->bf_getsegcount == NULL)
	1331	return converterr(
	1332	"string or read-only character buffer",
	1333	arg, msgbuf, bufsize);
	1334
	1335	if (pb->bf_getsegcount(arg, NULL) != 1)
	1336	return converterr(
	1337	"string or single-segment read-only buffer",
	1338	arg, msgbuf, bufsize);
	1339
	1340	if (pb->bf_releasebuffer)
	1341	return converterr(
	1342	"string or pinned buffer",
	1343	arg, msgbuf, bufsize);
	1344
	1345	count = pb->bf_getcharbuffer(arg, 0, p);
	1346	if (count < 0)
	1347	return converterr("(unspecified)", arg, msgbuf, bufsize);
	1348	{
	1349	FETCH_SIZE;
	1350	STORE_SIZE(count);
	1351	}
	1352	break;
	1353	}
	1354
	1355	default:
	1356	return converterr("impossible<bad format char>", arg, msgbuf, bufsize);
	1357
	1358	}
	1359
	1360	*p_format = format;
	1361	return NULL;
[2]	1362	}
	1363
	1364	static Py_ssize_t
	1365	convertbuffer(PyObject arg, void p, char *errmsg)
	1366	{
[391]	1367	PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
	1368	Py_ssize_t count;
	1369	if (pb == NULL \|\|
	1370	pb->bf_getreadbuffer == NULL \|\|
	1371	pb->bf_getsegcount == NULL \|\|
	1372	pb->bf_releasebuffer != NULL) {
	1373	*errmsg = "string or read-only buffer";
	1374	return -1;
	1375	}
	1376	if ((*pb->bf_getsegcount)(arg, NULL) != 1) {
	1377	*errmsg = "string or single-segment read-only buffer";
	1378	return -1;
	1379	}
	1380	if ((count = (*pb->bf_getreadbuffer)(arg, 0, p)) < 0) {
	1381	*errmsg = "(unspecified)";
	1382	}
	1383	return count;
[2]	1384	}
	1385
	1386	static int
	1387	getbuffer(PyObject arg, Py_buffer view, char **errmsg)
	1388	{
[391]	1389	void *buf;
	1390	Py_ssize_t count;
	1391	PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
	1392	if (pb == NULL) {
	1393	*errmsg = "string or buffer";
	1394	return -1;
	1395	}
	1396	if (pb->bf_getbuffer) {
	1397	if (pb->bf_getbuffer(arg, view, 0) < 0) {
	1398	*errmsg = "convertible to a buffer";
	1399	return -1;
	1400	}
	1401	if (!PyBuffer_IsContiguous(view, 'C')) {
	1402	*errmsg = "contiguous buffer";
	1403	return -1;
	1404	}
	1405	return 0;
	1406	}
[2]	1407
[391]	1408	count = convertbuffer(arg, &buf, errmsg);
	1409	if (count < 0) {
	1410	*errmsg = "convertible to a buffer";
	1411	return count;
	1412	}
	1413	PyBuffer_FillInfo(view, arg, buf, count, 1, 0);
	1414	return 0;
[2]	1415	}
	1416
	1417	/* Support for keyword arguments donated by
	1418	Geoff Philbrick <philbric@delphi.hks.com> */
	1419
	1420	/* Return false (0) for error, else true. */
	1421	int
	1422	PyArg_ParseTupleAndKeywords(PyObject *args,
[391]	1423	PyObject *keywords,
	1424	const char *format,
	1425	char **kwlist, ...)
[2]	1426	{
[391]	1427	int retval;
	1428	va_list va;
[2]	1429
[391]	1430	if ((args == NULL \|\| !PyTuple_Check(args)) \|\|
	1431	(keywords != NULL && !PyDict_Check(keywords)) \|\|
	1432	format == NULL \|\|
	1433	kwlist == NULL)
	1434	{
	1435	PyErr_BadInternalCall();
	1436	return 0;
	1437	}
[2]	1438
[391]	1439	va_start(va, kwlist);
	1440	retval = vgetargskeywords(args, keywords, format, kwlist, &va, 0);
	1441	va_end(va);
	1442	return retval;
[2]	1443	}
	1444
	1445	int
	1446	_PyArg_ParseTupleAndKeywords_SizeT(PyObject *args,
[391]	1447	PyObject *keywords,
	1448	const char *format,
	1449	char **kwlist, ...)
[2]	1450	{
[391]	1451	int retval;
	1452	va_list va;
[2]	1453
[391]	1454	if ((args == NULL \|\| !PyTuple_Check(args)) \|\|
	1455	(keywords != NULL && !PyDict_Check(keywords)) \|\|
	1456	format == NULL \|\|
	1457	kwlist == NULL)
	1458	{
	1459	PyErr_BadInternalCall();
	1460	return 0;
	1461	}
[2]	1462
[391]	1463	va_start(va, kwlist);
	1464	retval = vgetargskeywords(args, keywords, format,
	1465	kwlist, &va, FLAG_SIZE_T);
	1466	va_end(va);
	1467	return retval;
[2]	1468	}
	1469
	1470
	1471	int
	1472	PyArg_VaParseTupleAndKeywords(PyObject *args,
	1473	PyObject *keywords,
[391]	1474	const char *format,
[2]	1475	char **kwlist, va_list va)
	1476	{
[391]	1477	int retval;
	1478	va_list lva;
[2]	1479
[391]	1480	if ((args == NULL \|\| !PyTuple_Check(args)) \|\|
	1481	(keywords != NULL && !PyDict_Check(keywords)) \|\|
	1482	format == NULL \|\|
	1483	kwlist == NULL)
	1484	{
	1485	PyErr_BadInternalCall();
	1486	return 0;
	1487	}
[2]	1488
	1489	#ifdef VA_LIST_IS_ARRAY
[391]	1490	memcpy(lva, va, sizeof(va_list));
[2]	1491	#else
	1492	#ifdef __va_copy
[391]	1493	__va_copy(lva, va);
[2]	1494	#else
[391]	1495	lva = va;
[2]	1496	#endif
	1497	#endif
	1498
[391]	1499	retval = vgetargskeywords(args, keywords, format, kwlist, &lva, 0);
	1500	return retval;
[2]	1501	}
	1502
	1503	int
	1504	_PyArg_VaParseTupleAndKeywords_SizeT(PyObject *args,
[391]	1505	PyObject *keywords,
	1506	const char *format,
	1507	char **kwlist, va_list va)
[2]	1508	{
[391]	1509	int retval;
	1510	va_list lva;
[2]	1511
[391]	1512	if ((args == NULL \|\| !PyTuple_Check(args)) \|\|
	1513	(keywords != NULL && !PyDict_Check(keywords)) \|\|
	1514	format == NULL \|\|
	1515	kwlist == NULL)
	1516	{
	1517	PyErr_BadInternalCall();
	1518	return 0;
	1519	}
[2]	1520
	1521	#ifdef VA_LIST_IS_ARRAY
[391]	1522	memcpy(lva, va, sizeof(va_list));
[2]	1523	#else
	1524	#ifdef __va_copy
[391]	1525	__va_copy(lva, va);
[2]	1526	#else
[391]	1527	lva = va;
[2]	1528	#endif
	1529	#endif
	1530
[391]	1531	retval = vgetargskeywords(args, keywords, format,
	1532	kwlist, &lva, FLAG_SIZE_T);
	1533	return retval;
[2]	1534	}
	1535
	1536	#define IS_END_OF_FORMAT(c) (c == '\0' \|\| c == ';' \|\| c == ':')
	1537
	1538	static int
	1539	vgetargskeywords(PyObject args, PyObject keywords, const char *format,
[391]	1540	char *kwlist, va_list p_va, int flags)
[2]	1541	{
[391]	1542	char msgbuf[512];
	1543	int levels[32];
	1544	const char fname, msg, custom_msg, keyword;
	1545	int min = INT_MAX;
	1546	int i, len, nargs, nkeywords;
	1547	PyObject freelist = NULL, current_arg;
[2]	1548
[391]	1549	assert(args != NULL && PyTuple_Check(args));
	1550	assert(keywords == NULL \|\| PyDict_Check(keywords));
	1551	assert(format != NULL);
	1552	assert(kwlist != NULL);
	1553	assert(p_va != NULL);
[2]	1554
[391]	1555	/* grab the function name or custom error msg first (mutually exclusive) */
	1556	fname = strchr(format, ':');
	1557	if (fname) {
	1558	fname++;
	1559	custom_msg = NULL;
	1560	}
	1561	else {
	1562	custom_msg = strchr(format,';');
	1563	if (custom_msg)
	1564	custom_msg++;
	1565	}
[2]	1566
[391]	1567	/* scan kwlist and get greatest possible nbr of args */
	1568	for (len=0; kwlist[len]; len++)
	1569	continue;
[2]	1570
[391]	1571	nargs = PyTuple_GET_SIZE(args);
	1572	nkeywords = (keywords == NULL) ? 0 : PyDict_Size(keywords);
	1573	if (nargs + nkeywords > len) {
	1574	PyErr_Format(PyExc_TypeError, "%s%s takes at most %d "
	1575	"argument%s (%d given)",
	1576	(fname == NULL) ? "function" : fname,
	1577	(fname == NULL) ? "" : "()",
	1578	len,
	1579	(len == 1) ? "" : "s",
	1580	nargs + nkeywords);
	1581	return 0;
	1582	}
[2]	1583
[391]	1584	/* convert tuple args and keyword args in same loop, using kwlist to drive process */
	1585	for (i = 0; i < len; i++) {
	1586	keyword = kwlist[i];
	1587	if (*format == '\|') {
	1588	min = i;
	1589	format++;
	1590	}
	1591	if (IS_END_OF_FORMAT(*format)) {
	1592	PyErr_Format(PyExc_RuntimeError,
	1593	"More keyword list entries (%d) than "
	1594	"format specifiers (%d)", len, i);
	1595	return cleanreturn(0, freelist);
	1596	}
	1597	current_arg = NULL;
	1598	if (nkeywords) {
	1599	current_arg = PyDict_GetItemString(keywords, keyword);
	1600	}
	1601	if (current_arg) {
	1602	--nkeywords;
	1603	if (i < nargs) {
	1604	/* arg present in tuple and in dict */
	1605	PyErr_Format(PyExc_TypeError,
	1606	"Argument given by name ('%s') "
	1607	"and position (%d)",
	1608	keyword, i+1);
	1609	return cleanreturn(0, freelist);
	1610	}
	1611	}
	1612	else if (nkeywords && PyErr_Occurred())
	1613	return cleanreturn(0, freelist);
	1614	else if (i < nargs)
	1615	current_arg = PyTuple_GET_ITEM(args, i);
[2]	1616
[391]	1617	if (current_arg) {
	1618	msg = convertitem(current_arg, &format, p_va, flags,
	1619	levels, msgbuf, sizeof(msgbuf), &freelist);
	1620	if (msg) {
	1621	seterror(i+1, msg, levels, fname, custom_msg);
	1622	return cleanreturn(0, freelist);
	1623	}
	1624	continue;
	1625	}
[2]	1626
[391]	1627	if (i < min) {
	1628	PyErr_Format(PyExc_TypeError, "Required argument "
	1629	"'%s' (pos %d) not found",
	1630	keyword, i+1);
	1631	return cleanreturn(0, freelist);
	1632	}
	1633	/* current code reports success when all required args
	1634	* fulfilled and no keyword args left, with no further
	1635	* validation. XXX Maybe skip this in debug build ?
	1636	*/
	1637	if (!nkeywords)
	1638	return cleanreturn(1, freelist);
[2]	1639
[391]	1640	/* We are into optional args, skip thru to any remaining
	1641	* keyword args */
	1642	msg = skipitem(&format, p_va, flags);
	1643	if (msg) {
	1644	PyErr_Format(PyExc_RuntimeError, "%s: '%s'", msg,
	1645	format);
	1646	return cleanreturn(0, freelist);
	1647	}
	1648	}
[2]	1649
[391]	1650	if (!IS_END_OF_FORMAT(format) && format != '\|') {
	1651	PyErr_Format(PyExc_RuntimeError,
	1652	"more argument specifiers than keyword list entries "
	1653	"(remaining format:'%s')", format);
	1654	return cleanreturn(0, freelist);
	1655	}
[2]	1656
[391]	1657	/* make sure there are no extraneous keyword arguments */
	1658	if (nkeywords > 0) {
	1659	PyObject key, value;
	1660	Py_ssize_t pos = 0;
	1661	while (PyDict_Next(keywords, &pos, &key, &value)) {
	1662	int match = 0;
	1663	char *ks;
	1664	if (!PyString_Check(key)) {
	1665	PyErr_SetString(PyExc_TypeError,
	1666	"keywords must be strings");
	1667	return cleanreturn(0, freelist);
	1668	}
	1669	ks = PyString_AsString(key);
	1670	for (i = 0; i < len; i++) {
	1671	if (!strcmp(ks, kwlist[i])) {
	1672	match = 1;
	1673	break;
	1674	}
	1675	}
	1676	if (!match) {
	1677	PyErr_Format(PyExc_TypeError,
	1678	"'%s' is an invalid keyword "
	1679	"argument for this function",
	1680	ks);
	1681	return cleanreturn(0, freelist);
	1682	}
	1683	}
	1684	}
	1685
	1686	return cleanreturn(1, freelist);
[2]	1687	}
	1688
	1689
	1690	static char *
	1691	skipitem(const char *p_format, va_list p_va, int flags)
	1692	{
[391]	1693	const char format = p_format;
	1694	char c = *format++;
[2]	1695
[391]	1696	switch (c) {
[2]	1697
[391]	1698	/* simple codes
	1699	* The individual types (second arg of va_arg) are irrelevant */
	1700
	1701	case 'b': /* byte -- very short int */
	1702	case 'B': /* byte as bitfield */
	1703	case 'h': /* short int */
	1704	case 'H': /* short int as bitfield */
	1705	case 'i': /* int */
	1706	case 'I': /* int sized bitfield */
	1707	case 'l': /* long int */
	1708	case 'k': /* long int sized bitfield */
[2]	1709	#ifdef HAVE_LONG_LONG
[391]	1710	case 'L': /* PY_LONG_LONG */
	1711	case 'K': /* PY_LONG_LONG sized bitfield */
[2]	1712	#endif
[391]	1713	case 'f': /* float */
	1714	case 'd': /* double */
[2]	1715	#ifndef WITHOUT_COMPLEX
[391]	1716	case 'D': /* complex double */
[2]	1717	#endif
[391]	1718	case 'c': /* char */
	1719	{
	1720	(void) va_arg(p_va, void );
	1721	break;
	1722	}
[2]	1723
[391]	1724	case 'n': /* Py_ssize_t */
	1725	{
	1726	(void) va_arg(p_va, Py_ssize_t );
	1727	break;
	1728	}
	1729
	1730	/* string codes */
	1731
	1732	case 'e': /* string with encoding */
	1733	{
	1734	(void) va_arg(p_va, const char );
	1735	if (!(format == 's' \|\| format == 't'))
	1736	/* after 'e', only 's' and 't' is allowed */
	1737	goto err;
	1738	format++;
	1739	/* explicit fallthrough to string cases */
	1740	}
	1741
	1742	case 's': /* string */
	1743	case 'z': /* string or None */
[2]	1744	#ifdef Py_USING_UNICODE
[391]	1745	case 'u': /* unicode string */
[2]	1746	#endif
[391]	1747	case 't': /* buffer, read-only */
	1748	case 'w': /* buffer, read-write */
	1749	{
	1750	(void) va_arg(p_va, char *);
	1751	if (*format == '#') {
	1752	if (flags & FLAG_SIZE_T)
	1753	(void) va_arg(p_va, Py_ssize_t );
	1754	else
	1755	(void) va_arg(p_va, int );
	1756	format++;
	1757	} else if ((c == 's' \|\| c == 'z') && format == '') {
	1758	format++;
	1759	}
	1760	break;
	1761	}
[2]	1762
[391]	1763	/* object codes */
[2]	1764
[391]	1765	case 'S': /* string object */
[2]	1766	#ifdef Py_USING_UNICODE
[391]	1767	case 'U': /* unicode string object */
[2]	1768	#endif
[391]	1769	{
	1770	(void) va_arg(p_va, PyObject *);
	1771	break;
	1772	}
[2]	1773
[391]	1774	case 'O': /* object */
	1775	{
	1776	if (*format == '!') {
	1777	format++;
	1778	(void) va_arg(p_va, PyTypeObject);
	1779	(void) va_arg(p_va, PyObject *);
	1780	}
	1781	else if (*format == '&') {
	1782	typedef int (converter)(PyObject , void *);
	1783	(void) va_arg(*p_va, converter);
	1784	(void) va_arg(p_va, void );
	1785	format++;
	1786	}
	1787	else {
	1788	(void) va_arg(p_va, PyObject *);
	1789	}
	1790	break;
	1791	}
[2]	1792
[391]	1793	case '(': /* bypass tuple, not handled at all previously */
	1794	{
	1795	char *msg;
	1796	for (;;) {
	1797	if (*format==')')
	1798	break;
	1799	if (IS_END_OF_FORMAT(*format))
	1800	return "Unmatched left paren in format "
	1801	"string";
	1802	msg = skipitem(&format, p_va, flags);
	1803	if (msg)
	1804	return msg;
	1805	}
	1806	format++;
	1807	break;
	1808	}
[2]	1809
[391]	1810	case ')':
	1811	return "Unmatched right paren in format string";
	1812
	1813	default:
[2]	1814	err:
[391]	1815	return "impossible<bad format char>";
[2]	1816
[391]	1817	}
	1818
	1819	*p_format = format;
	1820	return NULL;
[2]	1821	}
	1822
	1823
	1824	int
	1825	PyArg_UnpackTuple(PyObject args, const char name, Py_ssize_t min, Py_ssize_t max, ...)
	1826	{
[391]	1827	Py_ssize_t i, l;
	1828	PyObject **o;
	1829	va_list vargs;
[2]	1830
	1831	#ifdef HAVE_STDARG_PROTOTYPES
[391]	1832	va_start(vargs, max);
[2]	1833	#else
[391]	1834	va_start(vargs);
[2]	1835	#endif
	1836
[391]	1837	assert(min >= 0);
	1838	assert(min <= max);
	1839	if (!PyTuple_Check(args)) {
	1840	va_end(vargs);
	1841	PyErr_SetString(PyExc_SystemError,
	1842	"PyArg_UnpackTuple() argument list is not a tuple");
	1843	return 0;
	1844	}
	1845	l = PyTuple_GET_SIZE(args);
	1846	if (l < min) {
	1847	if (name != NULL)
	1848	PyErr_Format(
	1849	PyExc_TypeError,
	1850	"%s expected %s%zd arguments, got %zd",
	1851	name, (min == max ? "" : "at least "), min, l);
	1852	else
	1853	PyErr_Format(
	1854	PyExc_TypeError,
	1855	"unpacked tuple should have %s%zd elements,"
	1856	" but has %zd",
	1857	(min == max ? "" : "at least "), min, l);
	1858	va_end(vargs);
	1859	return 0;
	1860	}
	1861	if (l > max) {
	1862	if (name != NULL)
	1863	PyErr_Format(
	1864	PyExc_TypeError,
	1865	"%s expected %s%zd arguments, got %zd",
	1866	name, (min == max ? "" : "at most "), max, l);
	1867	else
	1868	PyErr_Format(
	1869	PyExc_TypeError,
	1870	"unpacked tuple should have %s%zd elements,"
	1871	" but has %zd",
	1872	(min == max ? "" : "at most "), max, l);
	1873	va_end(vargs);
	1874	return 0;
	1875	}
	1876	for (i = 0; i < l; i++) {
	1877	o = va_arg(vargs, PyObject **);
	1878	*o = PyTuple_GET_ITEM(args, i);
	1879	}
	1880	va_end(vargs);
	1881	return 1;
[2]	1882	}
	1883
	1884
	1885	/* For type constructors that don't take keyword args
	1886	*
[391]	1887	* Sets a TypeError and returns 0 if the kwds dict is
[2]	1888	* not empty, returns 1 otherwise
	1889	*/
	1890	int
	1891	_PyArg_NoKeywords(const char funcname, PyObject kw)
	1892	{
[391]	1893	if (kw == NULL)
	1894	return 1;
	1895	if (!PyDict_CheckExact(kw)) {
	1896	PyErr_BadInternalCall();
	1897	return 0;
	1898	}
	1899	if (PyDict_Size(kw) == 0)
	1900	return 1;
	1901
	1902	PyErr_Format(PyExc_TypeError, "%s does not take keyword arguments",
	1903	funcname);
	1904	return 0;
[2]	1905	}
	1906	#ifdef __cplusplus
	1907	};
	1908	#endif

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: python/trunk/Python/getargs.c

Download in other formats: