2 /* New getargs implementation */
12 int PyArg_Parse(PyObject
*, const char *, ...);
13 int PyArg_ParseTuple(PyObject
*, const char *, ...);
14 int PyArg_VaParse(PyObject
*, const char *, va_list);
16 int PyArg_ParseTupleAndKeywords(PyObject
*, PyObject
*,
17 const char *, char **, ...);
18 int PyArg_VaParseTupleAndKeywords(PyObject
*, PyObject
*,
19 const char *, char **, va_list);
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);
38 static int vgetargs1(PyObject
*, const char *, va_list *, int);
39 static void seterror(int, const char *, int *, const char *, const char *);
40 static char *convertitem(PyObject
*, const char **, va_list *, int, int *,
41 char *, size_t, PyObject
**);
42 static char *converttuple(PyObject
*, const char **, va_list *, int,
43 int *, char *, size_t, int, PyObject
**);
44 static char *convertsimple(PyObject
*, const char **, va_list *, int, char *,
46 static Py_ssize_t
convertbuffer(PyObject
*, void **p
, char **);
48 static int vgetargskeywords(PyObject
*, PyObject
*,
49 const char *, char **, va_list *, int);
50 static char *skipitem(const char **, va_list *, int);
53 PyArg_Parse(PyObject
*args
, const char *format
, ...)
59 retval
= vgetargs1(args
, format
, &va
, FLAG_COMPAT
);
65 _PyArg_Parse_SizeT(PyObject
*args
, char *format
, ...)
71 retval
= vgetargs1(args
, format
, &va
, FLAG_COMPAT
|FLAG_SIZE_T
);
78 PyArg_ParseTuple(PyObject
*args
, const char *format
, ...)
84 retval
= vgetargs1(args
, format
, &va
, 0);
90 _PyArg_ParseTuple_SizeT(PyObject
*args
, char *format
, ...)
96 retval
= vgetargs1(args
, format
, &va
, FLAG_SIZE_T
);
103 PyArg_VaParse(PyObject
*args
, const char *format
, va_list va
)
107 #ifdef VA_LIST_IS_ARRAY
108 memcpy(lva
, va
, sizeof(va_list));
117 return vgetargs1(args
, format
, &lva
, 0);
121 _PyArg_VaParse_SizeT(PyObject
*args
, char *format
, va_list va
)
125 #ifdef VA_LIST_IS_ARRAY
126 memcpy(lva
, va
, sizeof(va_list));
135 return vgetargs1(args
, format
, &lva
, FLAG_SIZE_T
);
139 /* Handle cleanup of allocated memory in case of exception */
142 addcleanup(void *ptr
, PyObject
**freelist
)
146 *freelist
= PyList_New(0);
152 cobj
= PyCObject_FromVoidPtr(ptr
, NULL
);
157 if (PyList_Append(*freelist
, cobj
)) {
167 cleanreturn(int retval
, PyObject
*freelist
)
171 Py_ssize_t len
= PyList_GET_SIZE(freelist
), i
;
172 for (i
= 0; i
< len
; i
++)
173 PyMem_FREE(PyCObject_AsVoidPtr(
174 PyList_GET_ITEM(freelist
, i
)));
183 vgetargs1(PyObject
*args
, const char *format
, va_list *p_va
, int flags
)
187 const char *fname
= NULL
;
188 const char *message
= NULL
;
193 const char *formatsave
= format
;
196 PyObject
*freelist
= NULL
;
197 int compat
= flags
& FLAG_COMPAT
;
199 assert(compat
|| (args
!= (PyObject
*)NULL
));
200 flags
= flags
& ~FLAG_COMPAT
;
202 while (endfmt
== 0) {
210 Py_FatalError("too many tuple nesting levels "
211 "in argument format string");
215 Py_FatalError("excess ')' in getargs format");
234 else if (isalpha(Py_CHARMASK(c
))) {
235 if (c
!= 'e') /* skip encoded */
245 Py_FatalError(/* '(' */ "missing ')' in getargs format");
256 PyOS_snprintf(msgbuf
, sizeof(msgbuf
),
257 "%.200s%s takes no arguments",
258 fname
==NULL
? "function" : fname
,
259 fname
==NULL
? "" : "()");
260 PyErr_SetString(PyExc_TypeError
, msgbuf
);
263 else if (min
== 1 && max
== 1) {
265 PyOS_snprintf(msgbuf
, sizeof(msgbuf
),
266 "%.200s%s takes at least one argument",
267 fname
==NULL
? "function" : fname
,
268 fname
==NULL
? "" : "()");
269 PyErr_SetString(PyExc_TypeError
, msgbuf
);
272 msg
= convertitem(args
, &format
, p_va
, flags
, levels
,
273 msgbuf
, sizeof(msgbuf
), &freelist
);
275 return cleanreturn(1, freelist
);
276 seterror(levels
[0], msg
, levels
+1, fname
, message
);
277 return cleanreturn(0, freelist
);
280 PyErr_SetString(PyExc_SystemError
,
281 "old style getargs format uses new features");
286 if (!PyTuple_Check(args
)) {
287 PyErr_SetString(PyExc_SystemError
,
288 "new style getargs format but argument is not a tuple");
292 len
= PyTuple_GET_SIZE(args
);
294 if (len
< min
|| max
< len
) {
295 if (message
== NULL
) {
296 PyOS_snprintf(msgbuf
, sizeof(msgbuf
),
297 "%.150s%s takes %s %d argument%s "
299 fname
==NULL
? "function" : fname
,
300 fname
==NULL
? "" : "()",
302 : len
< min
? "at least" : "at most",
303 len
< min
? min
: max
,
304 (len
< min
? min
: max
) == 1 ? "" : "s",
305 Py_SAFE_DOWNCAST(len
, Py_ssize_t
, long));
308 PyErr_SetString(PyExc_TypeError
, message
);
312 for (i
= 0; i
< len
; i
++) {
315 msg
= convertitem(PyTuple_GET_ITEM(args
, i
), &format
, p_va
,
316 flags
, levels
, msgbuf
,
317 sizeof(msgbuf
), &freelist
);
319 seterror(i
+1, msg
, levels
, fname
, message
);
320 return cleanreturn(0, freelist
);
324 if (*format
!= '\0' && !isalpha(Py_CHARMASK(*format
)) &&
326 *format
!= '|' && *format
!= ':' && *format
!= ';') {
327 PyErr_Format(PyExc_SystemError
,
328 "bad format string: %.200s", formatsave
);
329 return cleanreturn(0, freelist
);
332 return cleanreturn(1, freelist
);
338 seterror(int iarg
, const char *msg
, int *levels
, const char *fname
,
345 if (PyErr_Occurred())
347 else if (message
== NULL
) {
349 PyOS_snprintf(p
, sizeof(buf
), "%.200s() ", fname
);
353 PyOS_snprintf(p
, sizeof(buf
) - (p
- buf
),
354 "argument %d", iarg
);
357 while (levels
[i
] > 0 && i
< 32 && (int)(p
-buf
) < 220) {
358 PyOS_snprintf(p
, sizeof(buf
) - (p
- buf
),
359 ", item %d", levels
[i
]-1);
365 PyOS_snprintf(p
, sizeof(buf
) - (p
- buf
), "argument");
368 PyOS_snprintf(p
, sizeof(buf
) - (p
- buf
), " %.256s", msg
);
371 PyErr_SetString(PyExc_TypeError
, message
);
375 /* Convert a tuple argument.
376 On entry, *p_format points to the character _after_ the opening '('.
377 On successful exit, *p_format points to the closing ')'.
379 *p_format and *p_va are updated,
380 *levels and *msgbuf are untouched,
381 and NULL is returned.
382 If the argument is invalid:
383 *p_format is unchanged,
385 *levels is a 0-terminated list of item numbers,
386 *msgbuf contains an error message, whose format is:
387 "must be <typename1>, not <typename2>", where:
388 <typename1> is the name of the expected type, and
389 <typename2> is the name of the actual type,
390 and msgbuf is returned.
394 converttuple(PyObject
*arg
, const char **p_format
, va_list *p_va
, int flags
,
395 int *levels
, char *msgbuf
, size_t bufsize
, int toplevel
,
400 const char *format
= *p_format
;
415 else if (c
== ':' || c
== ';' || c
== '\0')
417 else if (level
== 0 && isalpha(Py_CHARMASK(c
)))
421 if (!PySequence_Check(arg
) || PyBytes_Check(arg
)) {
423 PyOS_snprintf(msgbuf
, bufsize
,
424 toplevel
? "expected %d arguments, not %.50s" :
425 "must be %d-item sequence, not %.50s",
427 arg
== Py_None
? "None" : arg
->ob_type
->tp_name
);
431 if ((i
= PySequence_Size(arg
)) != n
) {
433 PyOS_snprintf(msgbuf
, bufsize
,
434 toplevel
? "expected %d arguments, not %d" :
435 "must be sequence of length %d, not %d",
441 for (i
= 0; i
< n
; i
++) {
444 item
= PySequence_GetItem(arg
, i
);
449 strncpy(msgbuf
, "is not retrievable", bufsize
);
452 msg
= convertitem(item
, &format
, p_va
, flags
, levels
+1,
453 msgbuf
, bufsize
, freelist
);
454 /* PySequence_GetItem calls tp->sq_item, which INCREFs */
467 /* Convert a single item. */
470 convertitem(PyObject
*arg
, const char **p_format
, va_list *p_va
, int flags
,
471 int *levels
, char *msgbuf
, size_t bufsize
, PyObject
**freelist
)
474 const char *format
= *p_format
;
476 if (*format
== '(' /* ')' */) {
478 msg
= converttuple(arg
, &format
, p_va
, flags
, levels
, msgbuf
,
479 bufsize
, 0, freelist
);
484 msg
= convertsimple(arg
, &format
, p_va
, flags
,
485 msgbuf
, bufsize
, freelist
);
496 #define UNICODE_DEFAULT_ENCODING(arg) \
497 _PyUnicode_AsDefaultEncodedString(arg, NULL)
499 /* Format an error message generated by convertsimple(). */
502 converterr(const char *expected
, PyObject
*arg
, char *msgbuf
, size_t bufsize
)
504 assert(expected
!= NULL
);
506 PyOS_snprintf(msgbuf
, bufsize
,
507 "must be %.50s, not %.50s", expected
,
508 arg
== Py_None
? "None" : arg
->ob_type
->tp_name
);
512 #define CONV_UNICODE "(unicode conversion error)"
514 /* explicitly check for float arguments when integers are expected. For now
515 * signal a warning. Returns true if an exception was raised. */
517 float_argument_error(PyObject
*arg
)
519 if (PyFloat_Check(arg
) &&
520 PyErr_Warn(PyExc_DeprecationWarning
,
521 "integer argument expected, got float" ))
527 /* Convert a non-tuple argument. Return NULL if conversion went OK,
528 or a string with a message describing the failure. The message is
529 formatted as "must be <desired type>, not <actual type>".
530 When failing, an exception may or may not have been raised.
531 Don't call if a tuple is expected.
533 When you add new format codes, please don't forget poor skipitem() below.
537 convertsimple(PyObject
*arg
, const char **p_format
, va_list *p_va
, int flags
,
538 char *msgbuf
, size_t bufsize
, PyObject
**freelist
)
541 #define FETCH_SIZE int *q=NULL;Py_ssize_t *q2=NULL;\
542 if (flags & FLAG_SIZE_T) q2=va_arg(*p_va, Py_ssize_t*); \
543 else q=va_arg(*p_va, int*);
544 #define STORE_SIZE(s) if (flags & FLAG_SIZE_T) *q2=s; else *q=s;
545 #define BUFFER_LEN ((flags & FLAG_SIZE_T) ? *q2:*q)
547 const char *format
= *p_format
;
549 #ifdef Py_USING_UNICODE
555 case 'b': { /* unsigned byte -- very short int */
556 char *p
= va_arg(*p_va
, char *);
558 if (float_argument_error(arg
))
559 return converterr("integer<b>", arg
, msgbuf
, bufsize
);
560 ival
= PyInt_AsLong(arg
);
561 if (ival
== -1 && PyErr_Occurred())
562 return converterr("integer<b>", arg
, msgbuf
, bufsize
);
564 PyErr_SetString(PyExc_OverflowError
,
565 "unsigned byte integer is less than minimum");
566 return converterr("integer<b>", arg
, msgbuf
, bufsize
);
568 else if (ival
> UCHAR_MAX
) {
569 PyErr_SetString(PyExc_OverflowError
,
570 "unsigned byte integer is greater than maximum");
571 return converterr("integer<b>", arg
, msgbuf
, bufsize
);
574 *p
= (unsigned char) ival
;
578 case 'B': {/* byte sized bitfield - both signed and unsigned
580 char *p
= va_arg(*p_va
, char *);
582 if (float_argument_error(arg
))
583 return converterr("integer<B>", arg
, msgbuf
, bufsize
);
584 ival
= PyInt_AsUnsignedLongMask(arg
);
585 if (ival
== -1 && PyErr_Occurred())
586 return converterr("integer<B>", arg
, msgbuf
, bufsize
);
588 *p
= (unsigned char) ival
;
592 case 'h': {/* signed short int */
593 short *p
= va_arg(*p_va
, short *);
595 if (float_argument_error(arg
))
596 return converterr("integer<h>", arg
, msgbuf
, bufsize
);
597 ival
= PyInt_AsLong(arg
);
598 if (ival
== -1 && PyErr_Occurred())
599 return converterr("integer<h>", arg
, msgbuf
, bufsize
);
600 else if (ival
< SHRT_MIN
) {
601 PyErr_SetString(PyExc_OverflowError
,
602 "signed short integer is less than minimum");
603 return converterr("integer<h>", arg
, msgbuf
, bufsize
);
605 else if (ival
> SHRT_MAX
) {
606 PyErr_SetString(PyExc_OverflowError
,
607 "signed short integer is greater than maximum");
608 return converterr("integer<h>", arg
, msgbuf
, bufsize
);
615 case 'H': { /* short int sized bitfield, both signed and
617 unsigned short *p
= va_arg(*p_va
, unsigned short *);
619 if (float_argument_error(arg
))
620 return converterr("integer<H>", arg
, msgbuf
, bufsize
);
621 ival
= PyInt_AsUnsignedLongMask(arg
);
622 if (ival
== -1 && PyErr_Occurred())
623 return converterr("integer<H>", arg
, msgbuf
, bufsize
);
625 *p
= (unsigned short) ival
;
629 case 'i': {/* signed int */
630 int *p
= va_arg(*p_va
, int *);
632 if (float_argument_error(arg
))
633 return converterr("integer<i>", arg
, msgbuf
, bufsize
);
634 ival
= PyInt_AsLong(arg
);
635 if (ival
== -1 && PyErr_Occurred())
636 return converterr("integer<i>", arg
, msgbuf
, bufsize
);
637 else if (ival
> INT_MAX
) {
638 PyErr_SetString(PyExc_OverflowError
,
639 "signed integer is greater than maximum");
640 return converterr("integer<i>", arg
, msgbuf
, bufsize
);
642 else if (ival
< INT_MIN
) {
643 PyErr_SetString(PyExc_OverflowError
,
644 "signed integer is less than minimum");
645 return converterr("integer<i>", arg
, msgbuf
, bufsize
);
652 case 'I': { /* int sized bitfield, both signed and
654 unsigned int *p
= va_arg(*p_va
, unsigned int *);
656 if (float_argument_error(arg
))
657 return converterr("integer<I>", arg
, msgbuf
, bufsize
);
658 ival
= (unsigned int)PyInt_AsUnsignedLongMask(arg
);
659 if (ival
== (unsigned int)-1 && PyErr_Occurred())
660 return converterr("integer<I>", arg
, msgbuf
, bufsize
);
666 case 'n': /* Py_ssize_t */
667 #if SIZEOF_SIZE_T != SIZEOF_LONG
669 Py_ssize_t
*p
= va_arg(*p_va
, Py_ssize_t
*);
671 if (float_argument_error(arg
))
672 return converterr("integer<n>", arg
, msgbuf
, bufsize
);
673 ival
= PyInt_AsSsize_t(arg
);
674 if (ival
== -1 && PyErr_Occurred())
675 return converterr("integer<n>", arg
, msgbuf
, bufsize
);
680 /* Fall through from 'n' to 'l' if Py_ssize_t is int */
681 case 'l': {/* long int */
682 long *p
= va_arg(*p_va
, long *);
684 if (float_argument_error(arg
))
685 return converterr("integer<l>", arg
, msgbuf
, bufsize
);
686 ival
= PyInt_AsLong(arg
);
687 if (ival
== -1 && PyErr_Occurred())
688 return converterr("integer<l>", arg
, msgbuf
, bufsize
);
694 case 'k': { /* long sized bitfield */
695 unsigned long *p
= va_arg(*p_va
, unsigned long *);
697 if (PyInt_Check(arg
))
698 ival
= PyInt_AsUnsignedLongMask(arg
);
699 else if (PyLong_Check(arg
))
700 ival
= PyLong_AsUnsignedLongMask(arg
);
702 return converterr("integer<k>", arg
, msgbuf
, bufsize
);
707 #ifdef HAVE_LONG_LONG
708 case 'L': {/* PY_LONG_LONG */
709 PY_LONG_LONG
*p
= va_arg( *p_va
, PY_LONG_LONG
* );
710 PY_LONG_LONG ival
= PyLong_AsLongLong( arg
);
711 if (ival
== (PY_LONG_LONG
)-1 && PyErr_Occurred() ) {
712 return converterr("long<L>", arg
, msgbuf
, bufsize
);
719 case 'K': { /* long long sized bitfield */
720 unsigned PY_LONG_LONG
*p
= va_arg(*p_va
, unsigned PY_LONG_LONG
*);
721 unsigned PY_LONG_LONG ival
;
722 if (PyInt_Check(arg
))
723 ival
= PyInt_AsUnsignedLongMask(arg
);
724 else if (PyLong_Check(arg
))
725 ival
= PyLong_AsUnsignedLongLongMask(arg
);
727 return converterr("integer<K>", arg
, msgbuf
, bufsize
);
733 case 'f': {/* float */
734 float *p
= va_arg(*p_va
, float *);
735 double dval
= PyFloat_AsDouble(arg
);
736 if (PyErr_Occurred())
737 return converterr("float<f>", arg
, msgbuf
, bufsize
);
743 case 'd': {/* double */
744 double *p
= va_arg(*p_va
, double *);
745 double dval
= PyFloat_AsDouble(arg
);
746 if (PyErr_Occurred())
747 return converterr("float<d>", arg
, msgbuf
, bufsize
);
753 #ifndef WITHOUT_COMPLEX
754 case 'D': {/* complex double */
755 Py_complex
*p
= va_arg(*p_va
, Py_complex
*);
757 cval
= PyComplex_AsCComplex(arg
);
758 if (PyErr_Occurred())
759 return converterr("complex<D>", arg
, msgbuf
, bufsize
);
764 #endif /* WITHOUT_COMPLEX */
766 case 'c': {/* char */
767 char *p
= va_arg(*p_va
, char *);
768 if (PyBytes_Check(arg
) && PyBytes_Size(arg
) == 1)
769 *p
= PyBytes_AS_STRING(arg
)[0];
771 return converterr("char", arg
, msgbuf
, bufsize
);
775 case 's': {/* string */
776 if (*format
== '#') {
777 void **p
= (void **)va_arg(*p_va
, char **);
780 if (PyBytes_Check(arg
)) {
781 *p
= PyBytes_AS_STRING(arg
);
782 STORE_SIZE(PyBytes_GET_SIZE(arg
));
784 #ifdef Py_USING_UNICODE
785 else if (PyUnicode_Check(arg
)) {
786 uarg
= UNICODE_DEFAULT_ENCODING(arg
);
788 return converterr(CONV_UNICODE
,
789 arg
, msgbuf
, bufsize
);
790 *p
= PyBytes_AS_STRING(uarg
);
791 STORE_SIZE(PyBytes_GET_SIZE(uarg
));
794 else { /* any buffer-like object */
796 Py_ssize_t count
= convertbuffer(arg
, p
, &buf
);
798 return converterr(buf
, arg
, msgbuf
, bufsize
);
803 char **p
= va_arg(*p_va
, char **);
805 if (PyBytes_Check(arg
))
806 *p
= PyBytes_AS_STRING(arg
);
807 #ifdef Py_USING_UNICODE
808 else if (PyUnicode_Check(arg
)) {
809 uarg
= UNICODE_DEFAULT_ENCODING(arg
);
811 return converterr(CONV_UNICODE
,
812 arg
, msgbuf
, bufsize
);
813 *p
= PyBytes_AS_STRING(uarg
);
817 return converterr("string", arg
, msgbuf
, bufsize
);
818 if ((Py_ssize_t
)strlen(*p
) != PyBytes_Size(arg
))
819 return converterr("string without null bytes",
820 arg
, msgbuf
, bufsize
);
825 case 'z': {/* string, may be NULL (None) */
826 if (*format
== '#') { /* any buffer-like object */
827 void **p
= (void **)va_arg(*p_va
, char **);
830 if (arg
== Py_None
) {
834 else if (PyBytes_Check(arg
)) {
835 *p
= PyBytes_AS_STRING(arg
);
836 STORE_SIZE(PyBytes_GET_SIZE(arg
));
838 #ifdef Py_USING_UNICODE
839 else if (PyUnicode_Check(arg
)) {
840 uarg
= UNICODE_DEFAULT_ENCODING(arg
);
842 return converterr(CONV_UNICODE
,
843 arg
, msgbuf
, bufsize
);
844 *p
= PyBytes_AS_STRING(uarg
);
845 STORE_SIZE(PyBytes_GET_SIZE(uarg
));
848 else { /* any buffer-like object */
850 Py_ssize_t count
= convertbuffer(arg
, p
, &buf
);
852 return converterr(buf
, arg
, msgbuf
, bufsize
);
857 char **p
= va_arg(*p_va
, char **);
861 else if (PyBytes_Check(arg
))
862 *p
= PyBytes_AS_STRING(arg
);
863 #ifdef Py_USING_UNICODE
864 else if (PyUnicode_Check(arg
)) {
865 uarg
= UNICODE_DEFAULT_ENCODING(arg
);
867 return converterr(CONV_UNICODE
,
868 arg
, msgbuf
, bufsize
);
869 *p
= PyBytes_AS_STRING(uarg
);
873 return converterr("string or None",
874 arg
, msgbuf
, bufsize
);
875 if (*format
== '#') {
877 assert(0); /* XXX redundant with if-case */
881 *q
= PyBytes_Size(arg
);
884 else if (*p
!= NULL
&&
885 (Py_ssize_t
)strlen(*p
) != PyBytes_Size(arg
))
887 "string without null bytes or None",
888 arg
, msgbuf
, bufsize
);
893 case 'e': {/* encoded string */
895 const char *encoding
;
900 /* Get 'e' parameter: the encoding name */
901 encoding
= (const char *)va_arg(*p_va
, const char *);
902 #ifdef Py_USING_UNICODE
903 if (encoding
== NULL
)
904 encoding
= PyUnicode_GetDefaultEncoding();
907 /* Get output buffer parameter:
908 's' (recode all objects via Unicode) or
909 't' (only recode non-string objects)
913 else if (*format
== 't')
917 "(unknown parser marker combination)",
918 arg
, msgbuf
, bufsize
);
919 buffer
= (char **)va_arg(*p_va
, char **);
922 return converterr("(buffer is NULL)",
923 arg
, msgbuf
, bufsize
);
926 if (!recode_strings
&& PyBytes_Check(arg
)) {
931 #ifdef Py_USING_UNICODE
934 /* Convert object to Unicode */
935 u
= PyUnicode_FromObject(arg
);
938 "string or unicode or text buffer",
939 arg
, msgbuf
, bufsize
);
941 /* Encode object; use default error handling */
942 s
= PyUnicode_AsEncodedString(u
,
947 return converterr("(encoding failed)",
948 arg
, msgbuf
, bufsize
);
949 if (!PyBytes_Check(s
)) {
952 "(encoder failed to return a string)",
953 arg
, msgbuf
, bufsize
);
956 return converterr("string<e>", arg
, msgbuf
, bufsize
);
959 size
= PyBytes_GET_SIZE(s
);
961 /* Write output; output is guaranteed to be 0-terminated */
962 if (*format
== '#') {
963 /* Using buffer length parameter '#':
965 - if *buffer is NULL, a new buffer of the
966 needed size is allocated and the data
967 copied into it; *buffer is updated to point
968 to the new buffer; the caller is
969 responsible for PyMem_Free()ing it after
972 - if *buffer is not NULL, the data is
973 copied to *buffer; *buffer_len has to be
974 set to the size of the buffer on input;
975 buffer overflow is signalled with an error;
976 buffer has to provide enough room for the
977 encoded string plus the trailing 0-byte
979 - in both cases, *buffer_len is updated to
980 the size of the buffer /excluding/ the
987 if (q
== NULL
&& q2
== NULL
) {
990 "(buffer_len is NULL)",
991 arg
, msgbuf
, bufsize
);
993 if (*buffer
== NULL
) {
994 *buffer
= PyMem_NEW(char, size
+ 1);
995 if (*buffer
== NULL
) {
999 arg
, msgbuf
, bufsize
);
1001 if (addcleanup(*buffer
, freelist
)) {
1004 "(cleanup problem)",
1005 arg
, msgbuf
, bufsize
);
1008 if (size
+ 1 > BUFFER_LEN
) {
1011 "(buffer overflow)",
1012 arg
, msgbuf
, bufsize
);
1016 PyBytes_AS_STRING(s
),
1020 /* Using a 0-terminated buffer:
1022 - the encoded string has to be 0-terminated
1023 for this variant to work; if it is not, an
1026 - a new buffer of the needed size is
1027 allocated and the data copied into it;
1028 *buffer is updated to point to the new
1029 buffer; the caller is responsible for
1030 PyMem_Free()ing it after usage
1033 if ((Py_ssize_t
)strlen(PyBytes_AS_STRING(s
))
1037 "(encoded string without NULL bytes)",
1038 arg
, msgbuf
, bufsize
);
1040 *buffer
= PyMem_NEW(char, size
+ 1);
1041 if (*buffer
== NULL
) {
1043 return converterr("(memory error)",
1044 arg
, msgbuf
, bufsize
);
1046 if (addcleanup(*buffer
, freelist
)) {
1048 return converterr("(cleanup problem)",
1049 arg
, msgbuf
, bufsize
);
1052 PyBytes_AS_STRING(s
),
1059 #ifdef Py_USING_UNICODE
1060 case 'u': {/* raw unicode buffer (Py_UNICODE *) */
1061 if (*format
== '#') { /* any buffer-like object */
1062 void **p
= (void **)va_arg(*p_va
, char **);
1064 if (PyUnicode_Check(arg
)) {
1065 *p
= PyUnicode_AS_UNICODE(arg
);
1066 STORE_SIZE(PyUnicode_GET_SIZE(arg
));
1069 return converterr("cannot convert raw buffers",
1070 arg
, msgbuf
, bufsize
);
1074 Py_UNICODE
**p
= va_arg(*p_va
, Py_UNICODE
**);
1075 if (PyUnicode_Check(arg
))
1076 *p
= PyUnicode_AS_UNICODE(arg
);
1078 return converterr("unicode", arg
, msgbuf
, bufsize
);
1084 case 'S': { /* string object */
1085 PyObject
**p
= va_arg(*p_va
, PyObject
**);
1086 if (PyBytes_Check(arg
))
1089 return converterr("string", arg
, msgbuf
, bufsize
);
1093 #ifdef Py_USING_UNICODE
1094 case 'U': { /* Unicode object */
1095 PyObject
**p
= va_arg(*p_va
, PyObject
**);
1096 if (PyUnicode_Check(arg
))
1099 return converterr("unicode", arg
, msgbuf
, bufsize
);
1104 case 'O': { /* object */
1107 if (*format
== '!') {
1108 type
= va_arg(*p_va
, PyTypeObject
*);
1109 p
= va_arg(*p_va
, PyObject
**);
1111 if (PyType_IsSubtype(arg
->ob_type
, type
))
1114 return converterr(type
->tp_name
, arg
, msgbuf
, bufsize
);
1117 else if (*format
== '?') {
1118 inquiry pred
= va_arg(*p_va
, inquiry
);
1119 p
= va_arg(*p_va
, PyObject
**);
1124 return converterr("(unspecified)",
1125 arg
, msgbuf
, bufsize
);
1128 else if (*format
== '&') {
1129 typedef int (*converter
)(PyObject
*, void *);
1130 converter convert
= va_arg(*p_va
, converter
);
1131 void *addr
= va_arg(*p_va
, void *);
1133 if (! (*convert
)(arg
, addr
))
1134 return converterr("(unspecified)",
1135 arg
, msgbuf
, bufsize
);
1138 p
= va_arg(*p_va
, PyObject
**);
1145 case 'w': { /* memory buffer, read-write access */
1146 void **p
= va_arg(*p_va
, void **);
1147 PyBufferProcs
*pb
= arg
->ob_type
->tp_as_buffer
;
1151 pb
->bf_getwritebuffer
== NULL
||
1152 pb
->bf_getsegcount
== NULL
)
1153 return converterr("read-write buffer", arg
, msgbuf
, bufsize
);
1154 if ((*pb
->bf_getsegcount
)(arg
, NULL
) != 1)
1155 return converterr("single-segment read-write buffer",
1156 arg
, msgbuf
, bufsize
);
1157 if ((count
= pb
->bf_getwritebuffer(arg
, 0, p
)) < 0)
1158 return converterr("(unspecified)", arg
, msgbuf
, bufsize
);
1159 if (*format
== '#') {
1167 case 't': { /* 8-bit character buffer, read-only access */
1168 char **p
= va_arg(*p_va
, char **);
1169 PyBufferProcs
*pb
= arg
->ob_type
->tp_as_buffer
;
1172 if (*format
++ != '#')
1174 "invalid use of 't' format character",
1175 arg
, msgbuf
, bufsize
);
1176 if (!PyType_HasFeature(arg
->ob_type
,
1177 Py_TPFLAGS_HAVE_GETCHARBUFFER
) ||
1178 pb
== NULL
|| pb
->bf_getcharbuffer
== NULL
||
1179 pb
->bf_getsegcount
== NULL
)
1181 "string or read-only character buffer",
1182 arg
, msgbuf
, bufsize
);
1184 if (pb
->bf_getsegcount(arg
, NULL
) != 1)
1186 "string or single-segment read-only buffer",
1187 arg
, msgbuf
, bufsize
);
1189 count
= pb
->bf_getcharbuffer(arg
, 0, p
);
1191 return converterr("(unspecified)", arg
, msgbuf
, bufsize
);
1200 return converterr("impossible<bad format char>", arg
, msgbuf
, bufsize
);
1209 convertbuffer(PyObject
*arg
, void **p
, char **errmsg
)
1211 PyBufferProcs
*pb
= arg
->ob_type
->tp_as_buffer
;
1214 pb
->bf_getreadbuffer
== NULL
||
1215 pb
->bf_getsegcount
== NULL
) {
1216 *errmsg
= "string or read-only buffer";
1219 if ((*pb
->bf_getsegcount
)(arg
, NULL
) != 1) {
1220 *errmsg
= "string or single-segment read-only buffer";
1223 if ((count
= (*pb
->bf_getreadbuffer
)(arg
, 0, p
)) < 0) {
1224 *errmsg
= "(unspecified)";
1229 /* Support for keyword arguments donated by
1230 Geoff Philbrick <philbric@delphi.hks.com> */
1232 /* Return false (0) for error, else true. */
1234 PyArg_ParseTupleAndKeywords(PyObject
*args
,
1242 if ((args
== NULL
|| !PyTuple_Check(args
)) ||
1243 (keywords
!= NULL
&& !PyDict_Check(keywords
)) ||
1247 PyErr_BadInternalCall();
1251 va_start(va
, kwlist
);
1252 retval
= vgetargskeywords(args
, keywords
, format
, kwlist
, &va
, 0);
1258 _PyArg_ParseTupleAndKeywords_SizeT(PyObject
*args
,
1266 if ((args
== NULL
|| !PyTuple_Check(args
)) ||
1267 (keywords
!= NULL
&& !PyDict_Check(keywords
)) ||
1271 PyErr_BadInternalCall();
1275 va_start(va
, kwlist
);
1276 retval
= vgetargskeywords(args
, keywords
, format
,
1277 kwlist
, &va
, FLAG_SIZE_T
);
1284 PyArg_VaParseTupleAndKeywords(PyObject
*args
,
1287 char **kwlist
, va_list va
)
1292 if ((args
== NULL
|| !PyTuple_Check(args
)) ||
1293 (keywords
!= NULL
&& !PyDict_Check(keywords
)) ||
1297 PyErr_BadInternalCall();
1301 #ifdef VA_LIST_IS_ARRAY
1302 memcpy(lva
, va
, sizeof(va_list));
1311 retval
= vgetargskeywords(args
, keywords
, format
, kwlist
, &lva
, 0);
1316 _PyArg_VaParseTupleAndKeywords_SizeT(PyObject
*args
,
1319 char **kwlist
, va_list va
)
1324 if ((args
== NULL
|| !PyTuple_Check(args
)) ||
1325 (keywords
!= NULL
&& !PyDict_Check(keywords
)) ||
1329 PyErr_BadInternalCall();
1333 #ifdef VA_LIST_IS_ARRAY
1334 memcpy(lva
, va
, sizeof(va_list));
1343 retval
= vgetargskeywords(args
, keywords
, format
,
1344 kwlist
, &lva
, FLAG_SIZE_T
);
1348 #define IS_END_OF_FORMAT(c) (c == '\0' || c == ';' || c == ':')
1351 vgetargskeywords(PyObject
*args
, PyObject
*keywords
, const char *format
,
1352 char **kwlist
, va_list *p_va
, int flags
)
1356 const char *fname
, *msg
, *custom_msg
, *keyword
;
1358 int i
, len
, nargs
, nkeywords
;
1359 PyObject
*freelist
= NULL
, *current_arg
;
1361 assert(args
!= NULL
&& PyTuple_Check(args
));
1362 assert(keywords
== NULL
|| PyDict_Check(keywords
));
1363 assert(format
!= NULL
);
1364 assert(kwlist
!= NULL
);
1365 assert(p_va
!= NULL
);
1367 /* grab the function name or custom error msg first (mutually exclusive) */
1368 fname
= strchr(format
, ':');
1374 custom_msg
= strchr(format
,';');
1379 /* scan kwlist and get greatest possible nbr of args */
1380 for (len
=0; kwlist
[len
]; len
++)
1383 nargs
= PyTuple_GET_SIZE(args
);
1384 nkeywords
= (keywords
== NULL
) ? 0 : PyDict_Size(keywords
);
1385 if (nargs
+ nkeywords
> len
) {
1386 PyErr_Format(PyExc_TypeError
, "%s%s takes at most %d "
1387 "argument%s (%d given)",
1388 (fname
== NULL
) ? "function" : fname
,
1389 (fname
== NULL
) ? "" : "()",
1391 (len
== 1) ? "" : "s",
1396 /* convert tuple args and keyword args in same loop, using kwlist to drive process */
1397 for (i
= 0; i
< len
; i
++) {
1398 keyword
= kwlist
[i
];
1399 if (*format
== '|') {
1403 if (IS_END_OF_FORMAT(*format
)) {
1404 PyErr_Format(PyExc_RuntimeError
,
1405 "More keyword list entries (%d) than "
1406 "format specifiers (%d)", len
, i
);
1407 return cleanreturn(0, freelist
);
1411 current_arg
= PyDict_GetItemString(keywords
, keyword
);
1416 /* arg present in tuple and in dict */
1417 PyErr_Format(PyExc_TypeError
,
1418 "Argument given by name ('%s') "
1419 "and position (%d)",
1421 return cleanreturn(0, freelist
);
1424 else if (nkeywords
&& PyErr_Occurred())
1425 return cleanreturn(0, freelist
);
1427 current_arg
= PyTuple_GET_ITEM(args
, i
);
1430 msg
= convertitem(current_arg
, &format
, p_va
, flags
,
1431 levels
, msgbuf
, sizeof(msgbuf
), &freelist
);
1433 seterror(i
+1, msg
, levels
, fname
, custom_msg
);
1434 return cleanreturn(0, freelist
);
1440 PyErr_Format(PyExc_TypeError
, "Required argument "
1441 "'%s' (pos %d) not found",
1443 return cleanreturn(0, freelist
);
1445 /* current code reports success when all required args
1446 * fulfilled and no keyword args left, with no further
1447 * validation. XXX Maybe skip this in debug build ?
1450 return cleanreturn(1, freelist
);
1452 /* We are into optional args, skip thru to any remaining
1454 msg
= skipitem(&format
, p_va
, flags
);
1456 PyErr_Format(PyExc_RuntimeError
, "%s: '%s'", msg
,
1458 return cleanreturn(0, freelist
);
1462 if (!IS_END_OF_FORMAT(*format
)) {
1463 PyErr_Format(PyExc_RuntimeError
,
1464 "more argument specifiers than keyword list entries "
1465 "(remaining format:'%s')", format
);
1466 return cleanreturn(0, freelist
);
1469 /* make sure there are no extraneous keyword arguments */
1470 if (nkeywords
> 0) {
1471 PyObject
*key
, *value
;
1473 while (PyDict_Next(keywords
, &pos
, &key
, &value
)) {
1476 if (!PyBytes_Check(key
)) {
1477 PyErr_SetString(PyExc_TypeError
,
1478 "keywords must be strings");
1479 return cleanreturn(0, freelist
);
1481 ks
= PyBytes_AsString(key
);
1482 for (i
= 0; i
< len
; i
++) {
1483 if (!strcmp(ks
, kwlist
[i
])) {
1489 PyErr_Format(PyExc_TypeError
,
1490 "'%s' is an invalid keyword "
1491 "argument for this function",
1493 return cleanreturn(0, freelist
);
1498 return cleanreturn(1, freelist
);
1503 skipitem(const char **p_format
, va_list *p_va
, int flags
)
1505 const char *format
= *p_format
;
1511 * The individual types (second arg of va_arg) are irrelevant */
1513 case 'b': /* byte -- very short int */
1514 case 'B': /* byte as bitfield */
1515 case 'h': /* short int */
1516 case 'H': /* short int as bitfield */
1518 case 'I': /* int sized bitfield */
1519 case 'l': /* long int */
1520 case 'k': /* long int sized bitfield */
1521 #ifdef HAVE_LONG_LONG
1522 case 'L': /* PY_LONG_LONG */
1523 case 'K': /* PY_LONG_LONG sized bitfield */
1525 case 'f': /* float */
1526 case 'd': /* double */
1527 #ifndef WITHOUT_COMPLEX
1528 case 'D': /* complex double */
1530 case 'c': /* char */
1532 (void) va_arg(*p_va
, void *);
1536 case 'n': /* Py_ssize_t */
1538 (void) va_arg(*p_va
, Py_ssize_t
*);
1544 case 'e': /* string with encoding */
1546 (void) va_arg(*p_va
, const char *);
1547 if (!(*format
== 's' || *format
== 't'))
1548 /* after 'e', only 's' and 't' is allowed */
1551 /* explicit fallthrough to string cases */
1554 case 's': /* string */
1555 case 'z': /* string or None */
1556 #ifdef Py_USING_UNICODE
1557 case 'u': /* unicode string */
1559 case 't': /* buffer, read-only */
1560 case 'w': /* buffer, read-write */
1562 (void) va_arg(*p_va
, char **);
1563 if (*format
== '#') {
1564 if (flags
& FLAG_SIZE_T
)
1565 (void) va_arg(*p_va
, Py_ssize_t
*);
1567 (void) va_arg(*p_va
, int *);
1575 case 'S': /* string object */
1576 #ifdef Py_USING_UNICODE
1577 case 'U': /* unicode string object */
1580 (void) va_arg(*p_va
, PyObject
**);
1584 case 'O': /* object */
1586 if (*format
== '!') {
1588 (void) va_arg(*p_va
, PyTypeObject
*);
1589 (void) va_arg(*p_va
, PyObject
**);
1592 /* I don't know what this is for */
1593 else if (*format
== '?') {
1594 inquiry pred
= va_arg(*p_va
, inquiry
);
1597 (void) va_arg(*p_va
, PyObject
**);
1601 else if (*format
== '&') {
1602 typedef int (*converter
)(PyObject
*, void *);
1603 (void) va_arg(*p_va
, converter
);
1604 (void) va_arg(*p_va
, void *);
1608 (void) va_arg(*p_va
, PyObject
**);
1613 case '(': /* bypass tuple, not handled at all previously */
1619 if (IS_END_OF_FORMAT(*format
))
1620 return "Unmatched left paren in format "
1622 msg
= skipitem(&format
, p_va
, flags
);
1631 return "Unmatched right paren in format string";
1635 return "impossible<bad format char>";
1645 PyArg_UnpackTuple(PyObject
*args
, const char *name
, Py_ssize_t min
, Py_ssize_t max
, ...)
1651 #ifdef HAVE_STDARG_PROTOTYPES
1652 va_start(vargs
, max
);
1659 if (!PyTuple_Check(args
)) {
1660 PyErr_SetString(PyExc_SystemError
,
1661 "PyArg_UnpackTuple() argument list is not a tuple");
1664 l
= PyTuple_GET_SIZE(args
);
1669 "%s expected %s%zd arguments, got %zd",
1670 name
, (min
== max
? "" : "at least "), min
, l
);
1674 "unpacked tuple should have %s%zd elements,"
1676 (min
== max
? "" : "at least "), min
, l
);
1684 "%s expected %s%zd arguments, got %zd",
1685 name
, (min
== max
? "" : "at most "), max
, l
);
1689 "unpacked tuple should have %s%zd elements,"
1691 (min
== max
? "" : "at most "), max
, l
);
1695 for (i
= 0; i
< l
; i
++) {
1696 o
= va_arg(vargs
, PyObject
**);
1697 *o
= PyTuple_GET_ITEM(args
, i
);
1704 /* For type constructors that don't take keyword args
1706 * Sets a TypeError and returns 0 if the kwds dict is
1707 * not empty, returns 1 otherwise
1710 _PyArg_NoKeywords(const char *funcname
, PyObject
*kw
)
1714 if (!PyDict_CheckExact(kw
)) {
1715 PyErr_BadInternalCall();
1718 if (PyDict_Size(kw
) == 0)
1721 PyErr_Format(PyExc_TypeError
, "%s does not take keyword arguments",