source: python/trunk/Python/getargs.c@ 389

Last change on this file since 389 was 2, checked in by Yuri Dario, 15 years ago

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