History

add hg and python

cinap_lenrek committed 15 years ago

Commit 4bb9e221 parent 987265c3706 files · +1228772 −-233Browse files

Showing the changes to sys/src/cmd/python/Python/getargs.c (1 of 3706 files). Show all

Unified · Split

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