[Python-checkins] CVS: python/dist/src/Python getargs.c,2.87,2.88

Jeremy Hylton jhylton@users.sourceforge.net
Wed, 28 Nov 2001 14:14:39 -0800


Update of /cvsroot/python/python/dist/src/Python
In directory usw-pr-cvs1:/tmp/cvs-serv6765

Modified Files:
	getargs.c 
Log Message:
Two screwups fixed for sizeof(char *) instead of sizeof(char []).

Also change all the helper functions to pass along the size of the
msgbuf and use PyOS_snprintf() when writing into the buffer.


Index: getargs.c
===================================================================
RCS file: /cvsroot/python/python/dist/src/Python/getargs.c,v
retrieving revision 2.87
retrieving revision 2.88
diff -C2 -d -r2.87 -r2.88
*** getargs.c	2001/11/28 21:46:59	2.87
--- getargs.c	2001/11/28 22:14:37	2.88
***************
*** 17,24 ****
  static int vgetargs1(PyObject *, char *, va_list *, int);
  static void seterror(int, char *, int *, char *, char *);
! static char *convertitem(PyObject *, char **, va_list *, int *, char *);
  static char *converttuple(PyObject *, char **, va_list *,
! 			  int *, char *, int);
! static char *convertsimple(PyObject *, char **, va_list *, char *);
  static int convertbuffer(PyObject *, void **p, char **);
  
--- 17,25 ----
  static int vgetargs1(PyObject *, char *, va_list *, int);
  static void seterror(int, char *, int *, char *, char *);
! static char *convertitem(PyObject *, char **, va_list *, int *, char *, 
! 			 size_t);
  static char *converttuple(PyObject *, char **, va_list *,
! 			  int *, char *, size_t, int);
! static char *convertsimple(PyObject *, char **, va_list *, char *, size_t);
  static int convertbuffer(PyObject *, void **p, char **);
  
***************
*** 152,156 ****
  				return 0;
  			}
! 			msg = convertitem(args, &format, p_va, levels, msgbuf);
  			if (msg == NULL)
  				return 1;
--- 153,158 ----
  				return 0;
  			}
! 			msg = convertitem(args, &format, p_va, levels, msgbuf,
! 					  sizeof(msgbuf));
  			if (msg == NULL)
  				return 1;
***************
*** 195,199 ****
  			format++;
  		msg = convertitem(PyTuple_GET_ITEM(args, i), &format, p_va,
! 				  levels, msgbuf);
  		if (msg) {
  			seterror(i+1, msg, levels, fname, message);
--- 197,201 ----
  			format++;
  		msg = convertitem(PyTuple_GET_ITEM(args, i), &format, p_va,
! 				  levels, msgbuf, sizeof(msgbuf));
  		if (msg) {
  			seterror(i+1, msg, levels, fname, message);
***************
*** 272,276 ****
  static char *
  converttuple(PyObject *arg, char **p_format, va_list *p_va, int *levels,
! 	     char *msgbuf, int toplevel)
  {
  	int level = 0;
--- 274,278 ----
  static char *
  converttuple(PyObject *arg, char **p_format, va_list *p_va, int *levels,
! 	     char *msgbuf, size_t bufsize, int toplevel)
  {
  	int level = 0;
***************
*** 299,303 ****
  	if (!PySequence_Check(arg) || PyString_Check(arg)) {
  		levels[0] = 0;
! 		PyOS_snprintf(msgbuf, sizeof(msgbuf),
  			      toplevel ? "expected %d arguments, not %.50s" :
  			              "must be %d-item sequence, not %.50s",
--- 301,305 ----
  	if (!PySequence_Check(arg) || PyString_Check(arg)) {
  		levels[0] = 0;
! 		PyOS_snprintf(msgbuf, bufsize,
  			      toplevel ? "expected %d arguments, not %.50s" :
  			              "must be %d-item sequence, not %.50s",
***************
*** 309,313 ****
  	if ((i = PySequence_Size(arg)) != n) {
  		levels[0] = 0;
! 		PyOS_snprintf(msgbuf, sizeof(msgbuf),
  			      toplevel ? "expected %d arguments, not %d" :
  			             "must be sequence of length %d, not %d",
--- 311,315 ----
  	if ((i = PySequence_Size(arg)) != n) {
  		levels[0] = 0;
! 		PyOS_snprintf(msgbuf, bufsize,
  			      toplevel ? "expected %d arguments, not %d" :
  			             "must be sequence of length %d, not %d",
***************
*** 321,325 ****
  		PyObject *item;
  		item = PySequence_GetItem(arg, i);
! 		msg = convertitem(item, &format, p_va, levels+1, msgbuf);
  		/* PySequence_GetItem calls tp->sq_item, which INCREFs */
  		Py_XDECREF(item);
--- 323,328 ----
  		PyObject *item;
  		item = PySequence_GetItem(arg, i);
! 		msg = convertitem(item, &format, p_va, levels+1, msgbuf,
! 				  bufsize);
  		/* PySequence_GetItem calls tp->sq_item, which INCREFs */
  		Py_XDECREF(item);
***************
*** 339,343 ****
  static char *
  convertitem(PyObject *arg, char **p_format, va_list *p_va, int *levels,
! 	    char *msgbuf)
  {
  	char *msg;
--- 342,346 ----
  static char *
  convertitem(PyObject *arg, char **p_format, va_list *p_va, int *levels,
! 	    char *msgbuf, size_t bufsize)
  {
  	char *msg;
***************
*** 346,355 ****
  	if (*format == '(' /* ')' */) {
  		format++;
! 		msg = converttuple(arg, &format, p_va, levels, msgbuf, 0);
  		if (msg == NULL)
  			format++;
  	}
  	else {
! 		msg = convertsimple(arg, &format, p_va, msgbuf);
  		if (msg != NULL)
  			levels[0] = 0;
--- 349,359 ----
  	if (*format == '(' /* ')' */) {
  		format++;
! 		msg = converttuple(arg, &format, p_va, levels, msgbuf, 
! 				   bufsize, 0);
  		if (msg == NULL)
  			format++;
  	}
  	else {
! 		msg = convertsimple(arg, &format, p_va, msgbuf, bufsize);
  		if (msg != NULL)
  			levels[0] = 0;
***************
*** 368,379 ****
  
  static char *
! converterr(char *expected, PyObject *arg, char *msgbuf)
  {
  	assert(expected != NULL);
  	assert(arg != NULL); 
! 	/* XXX use snprintf? */
! 	sprintf(msgbuf,
! 		"must be %.50s, not %.50s", expected,
! 		arg == Py_None ? "None" : arg->ob_type->tp_name);
  	return msgbuf;
  }
--- 372,382 ----
  
  static char *
! converterr(char *expected, PyObject *arg, char *msgbuf, size_t bufsize)
  {
  	assert(expected != NULL);
  	assert(arg != NULL); 
! 	PyOS_snprintf(msgbuf, bufsize,
! 		      "must be %.50s, not %.50s", expected,
! 		      arg == Py_None ? "None" : arg->ob_type->tp_name);
  	return msgbuf;
  }
***************
*** 389,393 ****
  
  static char *
! convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf)
  {
  	char *format = *p_format;
--- 392,397 ----
  
  static char *
! convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf,
! 	      size_t bufsize)
  {
  	char *format = *p_format;
***************
*** 401,414 ****
  		long ival = PyInt_AsLong(arg);
  		if (ival == -1 && PyErr_Occurred())
! 			return converterr("integer<b>", arg, msgbuf);
  		else if (ival < 0) {
  			PyErr_SetString(PyExc_OverflowError,
  			"unsigned byte integer is less than minimum");
! 			return converterr("integer<b>", arg, msgbuf);
  		}
  		else if (ival > UCHAR_MAX) {
  			PyErr_SetString(PyExc_OverflowError,
  			"unsigned byte integer is greater than maximum");
! 			return converterr("integer<b>", arg, msgbuf);
  		}
  		else
--- 405,418 ----
  		long ival = PyInt_AsLong(arg);
  		if (ival == -1 && PyErr_Occurred())
! 			return converterr("integer<b>", arg, msgbuf, bufsize);
  		else if (ival < 0) {
  			PyErr_SetString(PyExc_OverflowError,
  			"unsigned byte integer is less than minimum");
! 			return converterr("integer<b>", arg, msgbuf, bufsize);
  		}
  		else if (ival > UCHAR_MAX) {
  			PyErr_SetString(PyExc_OverflowError,
  			"unsigned byte integer is greater than maximum");
! 			return converterr("integer<b>", arg, msgbuf, bufsize);
  		}
  		else
***************
*** 422,435 ****
  		long ival = PyInt_AsLong(arg);
  		if (ival == -1 && PyErr_Occurred())
! 			return converterr("integer<b>", arg, msgbuf);
  		else if (ival < SCHAR_MIN) {
  			PyErr_SetString(PyExc_OverflowError,
  			"byte-sized integer bitfield is less than minimum");
! 			return converterr("integer<B>", arg, msgbuf);
  		}
  		else if (ival > (int)UCHAR_MAX) {
  			PyErr_SetString(PyExc_OverflowError,
  			"byte-sized integer bitfield is greater than maximum");
! 			return converterr("integer<B>", arg, msgbuf);
  		}
  		else
--- 426,439 ----
  		long ival = PyInt_AsLong(arg);
  		if (ival == -1 && PyErr_Occurred())
! 			return converterr("integer<b>", arg, msgbuf, bufsize);
  		else if (ival < SCHAR_MIN) {
  			PyErr_SetString(PyExc_OverflowError,
  			"byte-sized integer bitfield is less than minimum");
! 			return converterr("integer<B>", arg, msgbuf, bufsize);
  		}
  		else if (ival > (int)UCHAR_MAX) {
  			PyErr_SetString(PyExc_OverflowError,
  			"byte-sized integer bitfield is greater than maximum");
! 			return converterr("integer<B>", arg, msgbuf, bufsize);
  		}
  		else
***************
*** 442,455 ****
  		long ival = PyInt_AsLong(arg);
  		if (ival == -1 && PyErr_Occurred())
! 			return converterr("integer<h>", arg, msgbuf);
  		else if (ival < SHRT_MIN) {
  			PyErr_SetString(PyExc_OverflowError,
  			"signed short integer is less than minimum");
! 			return converterr("integer<h>", arg, msgbuf);
  		}
  		else if (ival > SHRT_MAX) {
  			PyErr_SetString(PyExc_OverflowError,
  			"signed short integer is greater than maximum");
! 			return converterr("integer<h>", arg, msgbuf);
  		}
  		else
--- 446,459 ----
  		long ival = PyInt_AsLong(arg);
  		if (ival == -1 && PyErr_Occurred())
! 			return converterr("integer<h>", arg, msgbuf, bufsize);
  		else if (ival < SHRT_MIN) {
  			PyErr_SetString(PyExc_OverflowError,
  			"signed short integer is less than minimum");
! 			return converterr("integer<h>", arg, msgbuf, bufsize);
  		}
  		else if (ival > SHRT_MAX) {
  			PyErr_SetString(PyExc_OverflowError,
  			"signed short integer is greater than maximum");
! 			return converterr("integer<h>", arg, msgbuf, bufsize);
  		}
  		else
***************
*** 463,476 ****
  		long ival = PyInt_AsLong(arg);
  		if (ival == -1 && PyErr_Occurred())
! 			return converterr("integer<H>", arg, msgbuf);
  		else if (ival < SHRT_MIN) {
  			PyErr_SetString(PyExc_OverflowError,
  			"short integer bitfield is less than minimum");
! 			return converterr("integer<H>", arg, msgbuf);
  		}
  		else if (ival > USHRT_MAX) {
  			PyErr_SetString(PyExc_OverflowError,
  			"short integer bitfield is greater than maximum");
! 			return converterr("integer<H>", arg, msgbuf);
  		}
  		else
--- 467,480 ----
  		long ival = PyInt_AsLong(arg);
  		if (ival == -1 && PyErr_Occurred())
! 			return converterr("integer<H>", arg, msgbuf, bufsize);
  		else if (ival < SHRT_MIN) {
  			PyErr_SetString(PyExc_OverflowError,
  			"short integer bitfield is less than minimum");
! 			return converterr("integer<H>", arg, msgbuf, bufsize);
  		}
  		else if (ival > USHRT_MAX) {
  			PyErr_SetString(PyExc_OverflowError,
  			"short integer bitfield is greater than maximum");
! 			return converterr("integer<H>", arg, msgbuf, bufsize);
  		}
  		else
***************
*** 483,496 ****
  		long ival = PyInt_AsLong(arg);
  		if (ival == -1 && PyErr_Occurred())
! 			return converterr("integer<i>", arg, msgbuf);
  		else if (ival > INT_MAX) {
  			PyErr_SetString(PyExc_OverflowError,
  				"signed integer is greater than maximum");
! 			return converterr("integer<i>", arg, msgbuf);
  		}
  		else if (ival < INT_MIN) {
  			PyErr_SetString(PyExc_OverflowError,
  				"signed integer is less than minimum");
! 			return converterr("integer<i>", arg, msgbuf);
  		}
  		else
--- 487,500 ----
  		long ival = PyInt_AsLong(arg);
  		if (ival == -1 && PyErr_Occurred())
! 			return converterr("integer<i>", arg, msgbuf, bufsize);
  		else if (ival > INT_MAX) {
  			PyErr_SetString(PyExc_OverflowError,
  				"signed integer is greater than maximum");
! 			return converterr("integer<i>", arg, msgbuf, bufsize);
  		}
  		else if (ival < INT_MIN) {
  			PyErr_SetString(PyExc_OverflowError,
  				"signed integer is less than minimum");
! 			return converterr("integer<i>", arg, msgbuf, bufsize);
  		}
  		else
***************
*** 503,507 ****
  		long ival = PyInt_AsLong(arg);
  		if (ival == -1 && PyErr_Occurred())
! 			return converterr("integer<l>", arg, msgbuf);
  		else
  			*p = ival;
--- 507,511 ----
  		long ival = PyInt_AsLong(arg);
  		if (ival == -1 && PyErr_Occurred())
! 			return converterr("integer<l>", arg, msgbuf, bufsize);
  		else
  			*p = ival;
***************
*** 514,518 ****
  		LONG_LONG ival = PyLong_AsLongLong( arg );
  		if( ival == (LONG_LONG)-1 && PyErr_Occurred() ) {
! 			return converterr("long<L>", arg, msgbuf);
  		} else {
  			*p = ival;
--- 518,522 ----
  		LONG_LONG ival = PyLong_AsLongLong( arg );
  		if( ival == (LONG_LONG)-1 && PyErr_Occurred() ) {
! 			return converterr("long<L>", arg, msgbuf, bufsize);
  		} else {
  			*p = ival;
***************
*** 526,530 ****
  		double dval = PyFloat_AsDouble(arg);
  		if (PyErr_Occurred())
! 			return converterr("float<f>", arg, msgbuf);
  		else
  			*p = (float) dval;
--- 530,534 ----
  		double dval = PyFloat_AsDouble(arg);
  		if (PyErr_Occurred())
! 			return converterr("float<f>", arg, msgbuf, bufsize);
  		else
  			*p = (float) dval;
***************
*** 536,540 ****
  		double dval = PyFloat_AsDouble(arg);
  		if (PyErr_Occurred())
! 			return converterr("float<d>", arg, msgbuf);
  		else
  			*p = dval;
--- 540,544 ----
  		double dval = PyFloat_AsDouble(arg);
  		if (PyErr_Occurred())
! 			return converterr("float<d>", arg, msgbuf, bufsize);
  		else
  			*p = dval;
***************
*** 548,552 ****
  		cval = PyComplex_AsCComplex(arg);
  		if (PyErr_Occurred())
! 			return converterr("complex<D>", arg, msgbuf);
  		else
  			*p = cval;
--- 552,556 ----
  		cval = PyComplex_AsCComplex(arg);
  		if (PyErr_Occurred())
! 			return converterr("complex<D>", arg, msgbuf, bufsize);
  		else
  			*p = cval;
***************
*** 560,564 ****
  			*p = PyString_AS_STRING(arg)[0];
  		else
! 			return converterr("char", arg, msgbuf);
  		break;
  	}
--- 564,568 ----
  			*p = PyString_AS_STRING(arg)[0];
  		else
! 			return converterr("char", arg, msgbuf, bufsize);
  		break;
  	}
***************
*** 578,582 ****
  				if (uarg == NULL)
  					return converterr(CONV_UNICODE,
! 							  arg, msgbuf);
  				*p = PyString_AS_STRING(uarg);
  				*q = PyString_GET_SIZE(uarg);
--- 582,586 ----
  				if (uarg == NULL)
  					return converterr(CONV_UNICODE,
! 							  arg, msgbuf, bufsize);
  				*p = PyString_AS_STRING(uarg);
  				*q = PyString_GET_SIZE(uarg);
***************
*** 587,591 ****
  				int count = convertbuffer(arg, p, &buf);
  				if (count < 0)
! 					return converterr(buf, arg, msgbuf);
  				*q = count;
  			}
--- 591,595 ----
  				int count = convertbuffer(arg, p, &buf);
  				if (count < 0)
! 					return converterr(buf, arg, msgbuf, bufsize);
  				*q = count;
  			}
***************
*** 601,613 ****
  				if (uarg == NULL)
  					return converterr(CONV_UNICODE,
! 							  arg, msgbuf);
  				*p = PyString_AS_STRING(uarg);
  			}
  #endif
  			else
! 				return converterr("string", arg, msgbuf);
  			if ((int)strlen(*p) != PyString_Size(arg))
  				return converterr("string without null bytes",
! 						  arg, msgbuf);
  		}
  		break;
--- 605,617 ----
  				if (uarg == NULL)
  					return converterr(CONV_UNICODE,
! 							  arg, msgbuf, bufsize);
  				*p = PyString_AS_STRING(uarg);
  			}
  #endif
  			else
! 				return converterr("string", arg, msgbuf, bufsize);
  			if ((int)strlen(*p) != PyString_Size(arg))
  				return converterr("string without null bytes",
! 						  arg, msgbuf, bufsize);
  		}
  		break;
***************
*** 632,636 ****
  				if (uarg == NULL)
  					return converterr(CONV_UNICODE,
! 							  arg, msgbuf);
  				*p = PyString_AS_STRING(uarg);
  				*q = PyString_GET_SIZE(uarg);
--- 636,640 ----
  				if (uarg == NULL)
  					return converterr(CONV_UNICODE,
! 							  arg, msgbuf, bufsize);
  				*p = PyString_AS_STRING(uarg);
  				*q = PyString_GET_SIZE(uarg);
***************
*** 641,645 ****
  				int count = convertbuffer(arg, p, &buf);
  				if (count < 0)
! 					return converterr(buf, arg, msgbuf);
  				*q = count;
  			}
--- 645,649 ----
  				int count = convertbuffer(arg, p, &buf);
  				if (count < 0)
! 					return converterr(buf, arg, msgbuf, bufsize);
  				*q = count;
  			}
***************
*** 657,661 ****
  				if (uarg == NULL)
  					return converterr(CONV_UNICODE,
! 							  arg, msgbuf);
  				*p = PyString_AS_STRING(uarg);
  			}
--- 661,665 ----
  				if (uarg == NULL)
  					return converterr(CONV_UNICODE,
! 							  arg, msgbuf, bufsize);
  				*p = PyString_AS_STRING(uarg);
  			}
***************
*** 663,667 ****
  			else
  				return converterr("string or None", 
! 						  arg, msgbuf);
  			if (*format == '#') {
  				int *q = va_arg(*p_va, int *);
--- 667,671 ----
  			else
  				return converterr("string or None", 
! 						  arg, msgbuf, bufsize);
  			if (*format == '#') {
  				int *q = va_arg(*p_va, int *);
***************
*** 676,680 ****
  				return converterr(
  					"string without null bytes or None", 
! 					arg, msgbuf);
  		}
  		break;
--- 680,684 ----
  				return converterr(
  					"string without null bytes or None", 
! 					arg, msgbuf, bufsize);
  		}
  		break;
***************
*** 705,714 ****
  			return converterr(
  				"(unknown parser marker combination)",
! 				arg, msgbuf);
  		buffer = (char **)va_arg(*p_va, char **);
  		format++;
  		if (buffer == NULL)
  			return converterr("(buffer is NULL)", 
! 					  arg, msgbuf);
  			
  		/* Encode object */
--- 709,718 ----
  			return converterr(
  				"(unknown parser marker combination)",
! 				arg, msgbuf, bufsize);
  		buffer = (char **)va_arg(*p_va, char **);
  		format++;
  		if (buffer == NULL)
  			return converterr("(buffer is NULL)", 
! 					  arg, msgbuf, bufsize);
  			
  		/* Encode object */
***************
*** 726,730 ****
  				return converterr(
  					"string or unicode or text buffer", 
! 					arg, msgbuf);
  			
  			/* Encode object; use default error handling */
--- 730,734 ----
  				return converterr(
  					"string or unicode or text buffer", 
! 					arg, msgbuf, bufsize);
  			
  			/* Encode object; use default error handling */
***************
*** 735,747 ****
  			if (s == NULL)
  				return converterr("(encoding failed)",
! 						  arg, msgbuf);
  			if (!PyString_Check(s)) {
  				Py_DECREF(s);
  				return converterr(
  					"(encoder failed to return a string)",
! 					arg, msgbuf);
  			}
  #else
! 			return converterr("string<e>", arg, msgbuf);
  #endif
  		}
--- 739,751 ----
  			if (s == NULL)
  				return converterr("(encoding failed)",
! 						  arg, msgbuf, bufsize);
  			if (!PyString_Check(s)) {
  				Py_DECREF(s);
  				return converterr(
  					"(encoder failed to return a string)",
! 					arg, msgbuf, bufsize);
  			}
  #else
! 			return converterr("string<e>", arg, msgbuf, bufsize);
  #endif
  		}
***************
*** 777,781 ****
  				return converterr(
  					"(buffer_len is NULL)",
! 					arg, msgbuf);
  			if (*buffer == NULL) {
  				*buffer = PyMem_NEW(char, size + 1);
--- 781,785 ----
  				return converterr(
  					"(buffer_len is NULL)",
! 					arg, msgbuf, bufsize);
  			if (*buffer == NULL) {
  				*buffer = PyMem_NEW(char, size + 1);
***************
*** 784,788 ****
  					return converterr(
  						"(memory error)",
! 						arg, msgbuf);
  				}
  			} else {
--- 788,792 ----
  					return converterr(
  						"(memory error)",
! 						arg, msgbuf, bufsize);
  				}
  			} else {
***************
*** 791,795 ****
  					return converterr(
  						"(buffer overflow)", 
! 						arg, msgbuf);
  				}
  			}
--- 795,799 ----
  					return converterr(
  						"(buffer overflow)", 
! 						arg, msgbuf, bufsize);
  				}
  			}
***************
*** 815,824 ****
  				return converterr(
  					"(encoded string without NULL bytes)",
! 					arg, msgbuf);
  			*buffer = PyMem_NEW(char, size + 1);
  			if (*buffer == NULL) {
  				Py_DECREF(s);
  				return converterr("(memory error)",
! 						  arg, msgbuf);
  			}
  			memcpy(*buffer,
--- 819,828 ----
  				return converterr(
  					"(encoded string without NULL bytes)",
! 					arg, msgbuf, bufsize);
  			*buffer = PyMem_NEW(char, size + 1);
  			if (*buffer == NULL) {
  				Py_DECREF(s);
  				return converterr("(memory error)",
! 						  arg, msgbuf, bufsize);
  			}
  			memcpy(*buffer,
***************
*** 839,843 ****
  
  			if (count < 0)
! 				return converterr(buf, arg, msgbuf);
  			*q = count/(sizeof(Py_UNICODE)); 
  			format++;
--- 843,847 ----
  
  			if (count < 0)
! 				return converterr(buf, arg, msgbuf, bufsize);
  			*q = count/(sizeof(Py_UNICODE)); 
  			format++;
***************
*** 848,852 ****
  				*p = PyUnicode_AS_UNICODE(arg);
  			else
! 				return converterr("unicode", arg, msgbuf);
  		}
  		break;
--- 852,856 ----
  				*p = PyUnicode_AS_UNICODE(arg);
  			else
! 				return converterr("unicode", arg, msgbuf, bufsize);
  		}
  		break;
***************
*** 859,863 ****
  			*p = arg;
  		else
! 			return converterr("string", arg, msgbuf);
  		break;
  	}
--- 863,867 ----
  			*p = arg;
  		else
! 			return converterr("string", arg, msgbuf, bufsize);
  		break;
  	}
***************
*** 869,873 ****
  			*p = arg;
  		else
! 			return converterr("unicode", arg, msgbuf);
  		break;
  	}
--- 873,877 ----
  			*p = arg;
  		else
! 			return converterr("unicode", arg, msgbuf, bufsize);
  		break;
  	}
***************
*** 884,888 ****
  				*p = arg;
  			else
! 				return converterr(type->tp_name, arg, msgbuf);
  
  		}
--- 888,892 ----
  				*p = arg;
  			else
! 				return converterr(type->tp_name, arg, msgbuf, bufsize);
  
  		}
***************
*** 895,899 ****
  			else
  				return converterr("(unspecified)", 
! 						  arg, msgbuf);
  				
  		}
--- 899,903 ----
  			else
  				return converterr("(unspecified)", 
! 						  arg, msgbuf, bufsize);
  				
  		}
***************
*** 905,909 ****
  			if (! (*convert)(arg, addr))
  				return converterr("(unspecified)", 
! 						  arg, msgbuf);
  		}
  		else {
--- 909,913 ----
  			if (! (*convert)(arg, addr))
  				return converterr("(unspecified)", 
! 						  arg, msgbuf, bufsize);
  		}
  		else {
***************
*** 923,932 ****
  		    pb->bf_getwritebuffer == NULL ||
  		    pb->bf_getsegcount == NULL)
! 			return converterr("read-write buffer", arg, msgbuf);
  		if ((*pb->bf_getsegcount)(arg, NULL) != 1)
  			return converterr("single-segment read-write buffer", 
! 					  arg, msgbuf);
  		if ((count = pb->bf_getwritebuffer(arg, 0, p)) < 0)
! 			return converterr("(unspecified)", arg, msgbuf);
  		if (*format == '#') {
  			int *q = va_arg(*p_va, int *);
--- 927,936 ----
  		    pb->bf_getwritebuffer == NULL ||
  		    pb->bf_getsegcount == NULL)
! 			return converterr("read-write buffer", arg, msgbuf, bufsize);
  		if ((*pb->bf_getsegcount)(arg, NULL) != 1)
  			return converterr("single-segment read-write buffer", 
! 					  arg, msgbuf, bufsize);
  		if ((count = pb->bf_getwritebuffer(arg, 0, p)) < 0)
! 			return converterr("(unspecified)", arg, msgbuf, bufsize);
  		if (*format == '#') {
  			int *q = va_arg(*p_va, int *);
***************
*** 946,950 ****
  			return converterr(
  				"invalid use of 't' format character", 
! 				arg, msgbuf);
  		if (!PyType_HasFeature(arg->ob_type,
  				       Py_TPFLAGS_HAVE_GETCHARBUFFER) ||
--- 950,954 ----
  			return converterr(
  				"invalid use of 't' format character", 
! 				arg, msgbuf, bufsize);
  		if (!PyType_HasFeature(arg->ob_type,
  				       Py_TPFLAGS_HAVE_GETCHARBUFFER) ||
***************
*** 953,966 ****
  			return converterr(
  				"string or read-only character buffer",
! 				arg, msgbuf);
  
  		if (pb->bf_getsegcount(arg, NULL) != 1)
  			return converterr(
  				"string or single-segment read-only buffer",
! 				arg, msgbuf);
  
  		count = pb->bf_getcharbuffer(arg, 0, p);
  		if (count < 0)
! 			return converterr("(unspecified)", arg, msgbuf);
  		*va_arg(*p_va, int *) = count;
  		break;
--- 957,970 ----
  			return converterr(
  				"string or read-only character buffer",
! 				arg, msgbuf, bufsize);
  
  		if (pb->bf_getsegcount(arg, NULL) != 1)
  			return converterr(
  				"string or single-segment read-only buffer",
! 				arg, msgbuf, bufsize);
  
  		count = pb->bf_getcharbuffer(arg, 0, p);
  		if (count < 0)
! 			return converterr("(unspecified)", arg, msgbuf, bufsize);
  		*va_arg(*p_va, int *) = count;
  		break;
***************
*** 968,972 ****
  
  	default:
! 		return converterr("impossible<bad format char>", arg, msgbuf);
  	
  	}
--- 972,976 ----
  
  	default:
! 		return converterr("impossible<bad format char>", arg, msgbuf, bufsize);
  	
  	}
***************
*** 1158,1162 ****
  			format++;
  		msg = convertitem(PyTuple_GET_ITEM(args, i), &format, p_va,
! 				 levels, msgbuf);
  		if (msg) {
  			seterror(i+1, msg, levels, fname, message);
--- 1162,1166 ----
  			format++;
  		msg = convertitem(PyTuple_GET_ITEM(args, i), &format, p_va,
! 				 levels, msgbuf, sizeof(msgbuf));
  		if (msg) {
  			seterror(i+1, msg, levels, fname, message);
***************
*** 1178,1182 ****
  		if (item != NULL) {
  			Py_INCREF(item);
! 			msg = convertitem(item, &format, p_va, levels, msgbuf);
  			Py_DECREF(item);
  			if (msg) {
--- 1182,1187 ----
  		if (item != NULL) {
  			Py_INCREF(item);
! 			msg = convertitem(item, &format, p_va, levels, msgbuf,
! 					  sizeof(msgbuf));
  			Py_DECREF(item);
  			if (msg) {