1
2 /* New getargs implementation */
3
4 #define PY_CXX_CONST const
5 #include "Python.h"
6 #include "pycore_abstract.h" // _PyNumber_Index()
7 #include "pycore_dict.h" // _PyDict_HasOnlyStringKeys()
8 #include "pycore_modsupport.h" // export _PyArg_NoKeywords()
9 #include "pycore_pylifecycle.h" // _PyArg_Fini
10 #include "pycore_pystate.h" // _Py_IsMainInterpreter()
11 #include "pycore_tuple.h" // _PyTuple_ITEMS()
12 #include "pycore_pyerrors.h" // _Py_CalculateSuggestions()
13
14 /* Export Stable ABIs (abi only) */
15 PyAPI_FUNC(int) _PyArg_Parse_SizeT(PyObject *, const char *, ...);
16 PyAPI_FUNC(int) _PyArg_ParseTuple_SizeT(PyObject *, const char *, ...);
17 PyAPI_FUNC(int) _PyArg_ParseTupleAndKeywords_SizeT(PyObject *, PyObject *,
18 const char *, const char * const *, ...);
19 PyAPI_FUNC(int) _PyArg_VaParse_SizeT(PyObject *, const char *, va_list);
20 PyAPI_FUNC(int) _PyArg_VaParseTupleAndKeywords_SizeT(PyObject *, PyObject *,
21 const char *, const char * const *, va_list);
22
23 #define FLAG_COMPAT 1
24
25 typedef int (*destr_t)(PyObject *, void *);
26
27
28 /* Keep track of "objects" that have been allocated or initialized and
29 which will need to be deallocated or cleaned up somehow if overall
30 parsing fails.
31 */
32 typedef struct {
33 void *item;
34 destr_t destructor;
35 } freelistentry_t;
36
37 typedef struct {
38 freelistentry_t *entries;
39 int first_available;
40 int entries_malloced;
41 } freelist_t;
42
43 #define STATIC_FREELIST_ENTRIES 8
44
45 /* Forward */
46 static int vgetargs1_impl(PyObject *args, PyObject *const *stack, Py_ssize_t nargs,
47 const char *format, va_list *p_va, int flags);
48 static int vgetargs1(PyObject *, const char *, va_list *, int);
49 static void seterror(Py_ssize_t, const char *, int *, const char *, const char *);
50 static const char *convertitem(PyObject *, const char **, va_list *, int, int *,
51 char *, size_t, freelist_t *);
52 static const char *converttuple(PyObject *, const char **, va_list *, int,
53 int *, char *, size_t, freelist_t *);
54 static const char *convertsimple(PyObject *, const char **, va_list *, int,
55 char *, size_t, freelist_t *);
56 static Py_ssize_t convertbuffer(PyObject *, const void **p, const char **);
57 static int getbuffer(PyObject *, Py_buffer *, const char**);
58
59 static int vgetargskeywords(PyObject *, PyObject *,
60 const char *, const char * const *, va_list *, int);
61 static int vgetargskeywordsfast(PyObject *, PyObject *,
62 struct _PyArg_Parser *, va_list *, int);
63 static int vgetargskeywordsfast_impl(PyObject *const *args, Py_ssize_t nargs,
64 PyObject *keywords, PyObject *kwnames,
65 struct _PyArg_Parser *parser,
66 va_list *p_va, int flags);
67 static const char *skipitem(const char **, va_list *, int);
68
69 int
PyArg_Parse(PyObject * args,const char * format,...)70 PyArg_Parse(PyObject *args, const char *format, ...)
71 {
72 int retval;
73 va_list va;
74
75 va_start(va, format);
76 retval = vgetargs1(args, format, &va, FLAG_COMPAT);
77 va_end(va);
78 return retval;
79 }
80
81 PyAPI_FUNC(int)
_PyArg_Parse_SizeT(PyObject * args,const char * format,...)82 _PyArg_Parse_SizeT(PyObject *args, const char *format, ...)
83 {
84 int retval;
85 va_list va;
86
87 va_start(va, format);
88 retval = vgetargs1(args, format, &va, FLAG_COMPAT);
89 va_end(va);
90 return retval;
91 }
92
93
94 int
PyArg_ParseTuple(PyObject * args,const char * format,...)95 PyArg_ParseTuple(PyObject *args, const char *format, ...)
96 {
97 int retval;
98 va_list va;
99
100 va_start(va, format);
101 retval = vgetargs1(args, format, &va, 0);
102 va_end(va);
103 return retval;
104 }
105
106 int
_PyArg_ParseTuple_SizeT(PyObject * args,const char * format,...)107 _PyArg_ParseTuple_SizeT(PyObject *args, const char *format, ...)
108 {
109 int retval;
110 va_list va;
111
112 va_start(va, format);
113 retval = vgetargs1(args, format, &va, 0);
114 va_end(va);
115 return retval;
116 }
117
118
119 int
_PyArg_ParseStack(PyObject * const * args,Py_ssize_t nargs,const char * format,...)120 _PyArg_ParseStack(PyObject *const *args, Py_ssize_t nargs, const char *format, ...)
121 {
122 int retval;
123 va_list va;
124
125 va_start(va, format);
126 retval = vgetargs1_impl(NULL, args, nargs, format, &va, 0);
127 va_end(va);
128 return retval;
129 }
130
131 int
PyArg_VaParse(PyObject * args,const char * format,va_list va)132 PyArg_VaParse(PyObject *args, const char *format, va_list va)
133 {
134 va_list lva;
135 int retval;
136
137 va_copy(lva, va);
138
139 retval = vgetargs1(args, format, &lva, 0);
140 va_end(lva);
141 return retval;
142 }
143
144 int
_PyArg_VaParse_SizeT(PyObject * args,const char * format,va_list va)145 _PyArg_VaParse_SizeT(PyObject *args, const char *format, va_list va)
146 {
147 va_list lva;
148 int retval;
149
150 va_copy(lva, va);
151
152 retval = vgetargs1(args, format, &lva, 0);
153 va_end(lva);
154 return retval;
155 }
156
157
158 /* Handle cleanup of allocated memory in case of exception */
159
160 static int
cleanup_ptr(PyObject * self,void * ptr)161 cleanup_ptr(PyObject *self, void *ptr)
162 {
163 void **pptr = (void **)ptr;
164 PyMem_Free(*pptr);
165 *pptr = NULL;
166 return 0;
167 }
168
169 static int
cleanup_buffer(PyObject * self,void * ptr)170 cleanup_buffer(PyObject *self, void *ptr)
171 {
172 Py_buffer *buf = (Py_buffer *)ptr;
173 if (buf) {
174 PyBuffer_Release(buf);
175 }
176 return 0;
177 }
178
179 static int
addcleanup(void * ptr,freelist_t * freelist,destr_t destructor)180 addcleanup(void *ptr, freelist_t *freelist, destr_t destructor)
181 {
182 int index;
183
184 index = freelist->first_available;
185 freelist->first_available += 1;
186
187 freelist->entries[index].item = ptr;
188 freelist->entries[index].destructor = destructor;
189
190 return 0;
191 }
192
193 static int
cleanreturn(int retval,freelist_t * freelist)194 cleanreturn(int retval, freelist_t *freelist)
195 {
196 int index;
197
198 if (retval == 0) {
199 /* A failure occurred, therefore execute all of the cleanup
200 functions.
201 */
202 for (index = 0; index < freelist->first_available; ++index) {
203 freelist->entries[index].destructor(NULL,
204 freelist->entries[index].item);
205 }
206 }
207 if (freelist->entries_malloced)
208 PyMem_Free(freelist->entries);
209 return retval;
210 }
211
212
213 static int
vgetargs1_impl(PyObject * compat_args,PyObject * const * stack,Py_ssize_t nargs,const char * format,va_list * p_va,int flags)214 vgetargs1_impl(PyObject *compat_args, PyObject *const *stack, Py_ssize_t nargs, const char *format,
215 va_list *p_va, int flags)
216 {
217 char msgbuf[256];
218 int levels[32];
219 const char *fname = NULL;
220 const char *message = NULL;
221 int min = -1;
222 int max = 0;
223 int level = 0;
224 int endfmt = 0;
225 const char *formatsave = format;
226 Py_ssize_t i;
227 const char *msg;
228 int compat = flags & FLAG_COMPAT;
229 freelistentry_t static_entries[STATIC_FREELIST_ENTRIES];
230 freelist_t freelist;
231
232 assert(nargs == 0 || stack != NULL);
233
234 freelist.entries = static_entries;
235 freelist.first_available = 0;
236 freelist.entries_malloced = 0;
237
238 flags = flags & ~FLAG_COMPAT;
239
240 while (endfmt == 0) {
241 int c = *format++;
242 switch (c) {
243 case '(':
244 if (level == 0)
245 max++;
246 level++;
247 if (level >= 30)
248 Py_FatalError("too many tuple nesting levels "
249 "in argument format string");
250 break;
251 case ')':
252 if (level == 0)
253 Py_FatalError("excess ')' in getargs format");
254 else
255 level--;
256 break;
257 case '\0':
258 endfmt = 1;
259 break;
260 case ':':
261 fname = format;
262 endfmt = 1;
263 break;
264 case ';':
265 message = format;
266 endfmt = 1;
267 break;
268 case '|':
269 if (level == 0)
270 min = max;
271 break;
272 default:
273 if (level == 0) {
274 if (Py_ISALPHA(c))
275 if (c != 'e') /* skip encoded */
276 max++;
277 }
278 break;
279 }
280 }
281
282 if (level != 0)
283 Py_FatalError(/* '(' */ "missing ')' in getargs format");
284
285 if (min < 0)
286 min = max;
287
288 format = formatsave;
289
290 if (max > STATIC_FREELIST_ENTRIES) {
291 freelist.entries = PyMem_NEW(freelistentry_t, max);
292 if (freelist.entries == NULL) {
293 PyErr_NoMemory();
294 return 0;
295 }
296 freelist.entries_malloced = 1;
297 }
298
299 if (compat) {
300 if (max == 0) {
301 if (compat_args == NULL)
302 return 1;
303 PyErr_Format(PyExc_TypeError,
304 "%.200s%s takes no arguments",
305 fname==NULL ? "function" : fname,
306 fname==NULL ? "" : "()");
307 return cleanreturn(0, &freelist);
308 }
309 else if (min == 1 && max == 1) {
310 if (compat_args == NULL) {
311 PyErr_Format(PyExc_TypeError,
312 "%.200s%s takes at least one argument",
313 fname==NULL ? "function" : fname,
314 fname==NULL ? "" : "()");
315 return cleanreturn(0, &freelist);
316 }
317 msg = convertitem(compat_args, &format, p_va, flags, levels,
318 msgbuf, sizeof(msgbuf), &freelist);
319 if (msg == NULL)
320 return cleanreturn(1, &freelist);
321 seterror(levels[0], msg, levels+1, fname, message);
322 return cleanreturn(0, &freelist);
323 }
324 else {
325 PyErr_SetString(PyExc_SystemError,
326 "old style getargs format uses new features");
327 return cleanreturn(0, &freelist);
328 }
329 }
330
331 if (nargs < min || max < nargs) {
332 if (message == NULL)
333 PyErr_Format(PyExc_TypeError,
334 "%.150s%s takes %s %d argument%s (%zd given)",
335 fname==NULL ? "function" : fname,
336 fname==NULL ? "" : "()",
337 min==max ? "exactly"
338 : nargs < min ? "at least" : "at most",
339 nargs < min ? min : max,
340 (nargs < min ? min : max) == 1 ? "" : "s",
341 nargs);
342 else
343 PyErr_SetString(PyExc_TypeError, message);
344 return cleanreturn(0, &freelist);
345 }
346
347 for (i = 0; i < nargs; i++) {
348 if (*format == '|')
349 format++;
350 msg = convertitem(stack[i], &format, p_va,
351 flags, levels, msgbuf,
352 sizeof(msgbuf), &freelist);
353 if (msg) {
354 seterror(i+1, msg, levels, fname, message);
355 return cleanreturn(0, &freelist);
356 }
357 }
358
359 if (*format != '\0' && !Py_ISALPHA(*format) &&
360 *format != '(' &&
361 *format != '|' && *format != ':' && *format != ';') {
362 PyErr_Format(PyExc_SystemError,
363 "bad format string: %.200s", formatsave);
364 return cleanreturn(0, &freelist);
365 }
366
367 return cleanreturn(1, &freelist);
368 }
369
370 static int
vgetargs1(PyObject * args,const char * format,va_list * p_va,int flags)371 vgetargs1(PyObject *args, const char *format, va_list *p_va, int flags)
372 {
373 PyObject **stack;
374 Py_ssize_t nargs;
375
376 if (!(flags & FLAG_COMPAT)) {
377 assert(args != NULL);
378
379 if (!PyTuple_Check(args)) {
380 PyErr_SetString(PyExc_SystemError,
381 "new style getargs format but argument is not a tuple");
382 return 0;
383 }
384
385 stack = _PyTuple_ITEMS(args);
386 nargs = PyTuple_GET_SIZE(args);
387 }
388 else {
389 stack = NULL;
390 nargs = 0;
391 }
392
393 return vgetargs1_impl(args, stack, nargs, format, p_va, flags);
394 }
395
396
397 static void
seterror(Py_ssize_t iarg,const char * msg,int * levels,const char * fname,const char * message)398 seterror(Py_ssize_t iarg, const char *msg, int *levels, const char *fname,
399 const char *message)
400 {
401 char buf[512];
402 int i;
403 char *p = buf;
404
405 if (PyErr_Occurred())
406 return;
407 else if (message == NULL) {
408 if (fname != NULL) {
409 PyOS_snprintf(p, sizeof(buf), "%.200s() ", fname);
410 p += strlen(p);
411 }
412 if (iarg != 0) {
413 PyOS_snprintf(p, sizeof(buf) - (p - buf),
414 "argument %zd", iarg);
415 i = 0;
416 p += strlen(p);
417 while (i < 32 && levels[i] > 0 && (int)(p-buf) < 220) {
418 PyOS_snprintf(p, sizeof(buf) - (p - buf),
419 ", item %d", levels[i]-1);
420 p += strlen(p);
421 i++;
422 }
423 }
424 else {
425 PyOS_snprintf(p, sizeof(buf) - (p - buf), "argument");
426 p += strlen(p);
427 }
428 PyOS_snprintf(p, sizeof(buf) - (p - buf), " %.256s", msg);
429 message = buf;
430 }
431 if (msg[0] == '(') {
432 PyErr_SetString(PyExc_SystemError, message);
433 }
434 else {
435 PyErr_SetString(PyExc_TypeError, message);
436 }
437 }
438
439
440 /* Convert a tuple argument.
441 On entry, *p_format points to the character _after_ the opening '('.
442 On successful exit, *p_format points to the closing ')'.
443 If successful:
444 *p_format and *p_va are updated,
445 *levels and *msgbuf are untouched,
446 and NULL is returned.
447 If the argument is invalid:
448 *p_format is unchanged,
449 *p_va is undefined,
450 *levels is a 0-terminated list of item numbers,
451 *msgbuf contains an error message, whose format is:
452 "must be <typename1>, not <typename2>", where:
453 <typename1> is the name of the expected type, and
454 <typename2> is the name of the actual type,
455 and msgbuf is returned.
456 */
457
458 static const char *
converttuple(PyObject * arg,const char ** p_format,va_list * p_va,int flags,int * levels,char * msgbuf,size_t bufsize,freelist_t * freelist)459 converttuple(PyObject *arg, const char **p_format, va_list *p_va, int flags,
460 int *levels, char *msgbuf, size_t bufsize,
461 freelist_t *freelist)
462 {
463 int level = 0;
464 int n = 0;
465 const char *format = *p_format;
466 int i;
467 Py_ssize_t len;
468
469 for (;;) {
470 int c = *format++;
471 if (c == '(') {
472 if (level == 0)
473 n++;
474 level++;
475 }
476 else if (c == ')') {
477 if (level == 0)
478 break;
479 level--;
480 }
481 else if (c == ':' || c == ';' || c == '\0')
482 break;
483 else if (level == 0 && Py_ISALPHA(c) && c != 'e')
484 n++;
485 }
486
487 if (!PySequence_Check(arg) || PyBytes_Check(arg)) {
488 levels[0] = 0;
489 PyOS_snprintf(msgbuf, bufsize,
490 "must be %d-item sequence, not %.50s",
491 n,
492 arg == Py_None ? "None" : Py_TYPE(arg)->tp_name);
493 return msgbuf;
494 }
495
496 len = PySequence_Size(arg);
497 if (len != n) {
498 levels[0] = 0;
499 PyOS_snprintf(msgbuf, bufsize,
500 "must be sequence of length %d, not %zd",
501 n, len);
502 return msgbuf;
503 }
504
505 format = *p_format;
506 for (i = 0; i < n; i++) {
507 const char *msg;
508 PyObject *item;
509 item = PySequence_GetItem(arg, i);
510 if (item == NULL) {
511 PyErr_Clear();
512 levels[0] = i+1;
513 levels[1] = 0;
514 strncpy(msgbuf, "is not retrievable", bufsize);
515 return msgbuf;
516 }
517 msg = convertitem(item, &format, p_va, flags, levels+1,
518 msgbuf, bufsize, freelist);
519 /* PySequence_GetItem calls tp->sq_item, which INCREFs */
520 Py_XDECREF(item);
521 if (msg != NULL) {
522 levels[0] = i+1;
523 return msg;
524 }
525 }
526
527 *p_format = format;
528 return NULL;
529 }
530
531
532 /* Convert a single item. */
533
534 static const char *
convertitem(PyObject * arg,const char ** p_format,va_list * p_va,int flags,int * levels,char * msgbuf,size_t bufsize,freelist_t * freelist)535 convertitem(PyObject *arg, const char **p_format, va_list *p_va, int flags,
536 int *levels, char *msgbuf, size_t bufsize, freelist_t *freelist)
537 {
538 const char *msg;
539 const char *format = *p_format;
540
541 if (*format == '(' /* ')' */) {
542 format++;
543 msg = converttuple(arg, &format, p_va, flags, levels, msgbuf,
544 bufsize, freelist);
545 if (msg == NULL)
546 format++;
547 }
548 else {
549 msg = convertsimple(arg, &format, p_va, flags,
550 msgbuf, bufsize, freelist);
551 if (msg != NULL)
552 levels[0] = 0;
553 }
554 if (msg == NULL)
555 *p_format = format;
556 return msg;
557 }
558
559
560
561 /* Format an error message generated by convertsimple().
562 displayname must be UTF-8 encoded.
563 */
564
565 void
_PyArg_BadArgument(const char * fname,const char * displayname,const char * expected,PyObject * arg)566 _PyArg_BadArgument(const char *fname, const char *displayname,
567 const char *expected, PyObject *arg)
568 {
569 PyErr_Format(PyExc_TypeError,
570 "%.200s() %.200s must be %.50s, not %.50s",
571 fname, displayname, expected,
572 arg == Py_None ? "None" : Py_TYPE(arg)->tp_name);
573 }
574
575 static const char *
converterr(const char * expected,PyObject * arg,char * msgbuf,size_t bufsize)576 converterr(const char *expected, PyObject *arg, char *msgbuf, size_t bufsize)
577 {
578 assert(expected != NULL);
579 assert(arg != NULL);
580 if (expected[0] == '(') {
581 PyOS_snprintf(msgbuf, bufsize,
582 "%.100s", expected);
583 }
584 else {
585 PyOS_snprintf(msgbuf, bufsize,
586 "must be %.50s, not %.50s", expected,
587 arg == Py_None ? "None" : Py_TYPE(arg)->tp_name);
588 }
589 return msgbuf;
590 }
591
592 #define CONV_UNICODE "(unicode conversion error)"
593
594 /* Convert a non-tuple argument. Return NULL if conversion went OK,
595 or a string with a message describing the failure. The message is
596 formatted as "must be <desired type>, not <actual type>".
597 When failing, an exception may or may not have been raised.
598 Don't call if a tuple is expected.
599
600 When you add new format codes, please don't forget poor skipitem() below.
601 */
602
603 static const char *
convertsimple(PyObject * arg,const char ** p_format,va_list * p_va,int flags,char * msgbuf,size_t bufsize,freelist_t * freelist)604 convertsimple(PyObject *arg, const char **p_format, va_list *p_va, int flags,
605 char *msgbuf, size_t bufsize, freelist_t *freelist)
606 {
607 #define RETURN_ERR_OCCURRED return msgbuf
608
609 const char *format = *p_format;
610 char c = *format++;
611 const char *sarg;
612
613 switch (c) {
614
615 case 'b': { /* unsigned byte -- very short int */
616 unsigned char *p = va_arg(*p_va, unsigned char *);
617 long ival = PyLong_AsLong(arg);
618 if (ival == -1 && PyErr_Occurred())
619 RETURN_ERR_OCCURRED;
620 else if (ival < 0) {
621 PyErr_SetString(PyExc_OverflowError,
622 "unsigned byte integer is less than minimum");
623 RETURN_ERR_OCCURRED;
624 }
625 else if (ival > UCHAR_MAX) {
626 PyErr_SetString(PyExc_OverflowError,
627 "unsigned byte integer is greater than maximum");
628 RETURN_ERR_OCCURRED;
629 }
630 else
631 *p = (unsigned char) ival;
632 break;
633 }
634
635 case 'B': {/* byte sized bitfield - both signed and unsigned
636 values allowed */
637 unsigned char *p = va_arg(*p_va, unsigned char *);
638 unsigned long ival = PyLong_AsUnsignedLongMask(arg);
639 if (ival == (unsigned long)-1 && PyErr_Occurred())
640 RETURN_ERR_OCCURRED;
641 else
642 *p = (unsigned char) ival;
643 break;
644 }
645
646 case 'h': {/* signed short int */
647 short *p = va_arg(*p_va, short *);
648 long ival = PyLong_AsLong(arg);
649 if (ival == -1 && PyErr_Occurred())
650 RETURN_ERR_OCCURRED;
651 else if (ival < SHRT_MIN) {
652 PyErr_SetString(PyExc_OverflowError,
653 "signed short integer is less than minimum");
654 RETURN_ERR_OCCURRED;
655 }
656 else if (ival > SHRT_MAX) {
657 PyErr_SetString(PyExc_OverflowError,
658 "signed short integer is greater than maximum");
659 RETURN_ERR_OCCURRED;
660 }
661 else
662 *p = (short) ival;
663 break;
664 }
665
666 case 'H': { /* short int sized bitfield, both signed and
667 unsigned allowed */
668 unsigned short *p = va_arg(*p_va, unsigned short *);
669 unsigned long ival = PyLong_AsUnsignedLongMask(arg);
670 if (ival == (unsigned long)-1 && PyErr_Occurred())
671 RETURN_ERR_OCCURRED;
672 else
673 *p = (unsigned short) ival;
674 break;
675 }
676
677 case 'i': {/* signed int */
678 int *p = va_arg(*p_va, int *);
679 long ival = PyLong_AsLong(arg);
680 if (ival == -1 && PyErr_Occurred())
681 RETURN_ERR_OCCURRED;
682 else if (ival > INT_MAX) {
683 PyErr_SetString(PyExc_OverflowError,
684 "signed integer is greater than maximum");
685 RETURN_ERR_OCCURRED;
686 }
687 else if (ival < INT_MIN) {
688 PyErr_SetString(PyExc_OverflowError,
689 "signed integer is less than minimum");
690 RETURN_ERR_OCCURRED;
691 }
692 else
693 *p = ival;
694 break;
695 }
696
697 case 'I': { /* int sized bitfield, both signed and
698 unsigned allowed */
699 unsigned int *p = va_arg(*p_va, unsigned int *);
700 unsigned long ival = PyLong_AsUnsignedLongMask(arg);
701 if (ival == (unsigned long)-1 && PyErr_Occurred())
702 RETURN_ERR_OCCURRED;
703 else
704 *p = (unsigned int) ival;
705 break;
706 }
707
708 case 'n': /* Py_ssize_t */
709 {
710 PyObject *iobj;
711 Py_ssize_t *p = va_arg(*p_va, Py_ssize_t *);
712 Py_ssize_t ival = -1;
713 iobj = _PyNumber_Index(arg);
714 if (iobj != NULL) {
715 ival = PyLong_AsSsize_t(iobj);
716 Py_DECREF(iobj);
717 }
718 if (ival == -1 && PyErr_Occurred())
719 RETURN_ERR_OCCURRED;
720 *p = ival;
721 break;
722 }
723 case 'l': {/* long int */
724 long *p = va_arg(*p_va, long *);
725 long ival = PyLong_AsLong(arg);
726 if (ival == -1 && PyErr_Occurred())
727 RETURN_ERR_OCCURRED;
728 else
729 *p = ival;
730 break;
731 }
732
733 case 'k': { /* long sized bitfield */
734 unsigned long *p = va_arg(*p_va, unsigned long *);
735 unsigned long ival;
736 if (PyLong_Check(arg))
737 ival = PyLong_AsUnsignedLongMask(arg);
738 else
739 return converterr("int", arg, msgbuf, bufsize);
740 *p = ival;
741 break;
742 }
743
744 case 'L': {/* long long */
745 long long *p = va_arg( *p_va, long long * );
746 long long ival = PyLong_AsLongLong(arg);
747 if (ival == (long long)-1 && PyErr_Occurred())
748 RETURN_ERR_OCCURRED;
749 else
750 *p = ival;
751 break;
752 }
753
754 case 'K': { /* long long sized bitfield */
755 unsigned long long *p = va_arg(*p_va, unsigned long long *);
756 unsigned long long ival;
757 if (PyLong_Check(arg))
758 ival = PyLong_AsUnsignedLongLongMask(arg);
759 else
760 return converterr("int", arg, msgbuf, bufsize);
761 *p = ival;
762 break;
763 }
764
765 case 'f': {/* float */
766 float *p = va_arg(*p_va, float *);
767 double dval = PyFloat_AsDouble(arg);
768 if (dval == -1.0 && PyErr_Occurred())
769 RETURN_ERR_OCCURRED;
770 else
771 *p = (float) dval;
772 break;
773 }
774
775 case 'd': {/* double */
776 double *p = va_arg(*p_va, double *);
777 double dval = PyFloat_AsDouble(arg);
778 if (dval == -1.0 && PyErr_Occurred())
779 RETURN_ERR_OCCURRED;
780 else
781 *p = dval;
782 break;
783 }
784
785 case 'D': {/* complex double */
786 Py_complex *p = va_arg(*p_va, Py_complex *);
787 Py_complex cval;
788 cval = PyComplex_AsCComplex(arg);
789 if (PyErr_Occurred())
790 RETURN_ERR_OCCURRED;
791 else
792 *p = cval;
793 break;
794 }
795
796 case 'c': {/* char */
797 char *p = va_arg(*p_va, char *);
798 if (PyBytes_Check(arg) && PyBytes_Size(arg) == 1)
799 *p = PyBytes_AS_STRING(arg)[0];
800 else if (PyByteArray_Check(arg) && PyByteArray_Size(arg) == 1)
801 *p = PyByteArray_AS_STRING(arg)[0];
802 else
803 return converterr("a byte string of length 1", arg, msgbuf, bufsize);
804 break;
805 }
806
807 case 'C': {/* unicode char */
808 int *p = va_arg(*p_va, int *);
809 int kind;
810 const void *data;
811
812 if (!PyUnicode_Check(arg))
813 return converterr("a unicode character", arg, msgbuf, bufsize);
814
815 if (PyUnicode_GET_LENGTH(arg) != 1)
816 return converterr("a unicode character", arg, msgbuf, bufsize);
817
818 kind = PyUnicode_KIND(arg);
819 data = PyUnicode_DATA(arg);
820 *p = PyUnicode_READ(kind, data, 0);
821 break;
822 }
823
824 case 'p': {/* boolean *p*redicate */
825 int *p = va_arg(*p_va, int *);
826 int val = PyObject_IsTrue(arg);
827 if (val > 0)
828 *p = 1;
829 else if (val == 0)
830 *p = 0;
831 else
832 RETURN_ERR_OCCURRED;
833 break;
834 }
835
836 /* XXX WAAAAH! 's', 'y', 'z', 'u', 'Z', 'e', 'w' codes all
837 need to be cleaned up! */
838
839 case 'y': {/* any bytes-like object */
840 void **p = (void **)va_arg(*p_va, char **);
841 const char *buf;
842 Py_ssize_t count;
843 if (*format == '*') {
844 if (getbuffer(arg, (Py_buffer*)p, &buf) < 0)
845 return converterr(buf, arg, msgbuf, bufsize);
846 format++;
847 if (addcleanup(p, freelist, cleanup_buffer)) {
848 return converterr(
849 "(cleanup problem)",
850 arg, msgbuf, bufsize);
851 }
852 break;
853 }
854 count = convertbuffer(arg, (const void **)p, &buf);
855 if (count < 0)
856 return converterr(buf, arg, msgbuf, bufsize);
857 if (*format == '#') {
858 Py_ssize_t *psize = va_arg(*p_va, Py_ssize_t*);
859 *psize = count;
860 format++;
861 } else {
862 if (strlen(*p) != (size_t)count) {
863 PyErr_SetString(PyExc_ValueError, "embedded null byte");
864 RETURN_ERR_OCCURRED;
865 }
866 }
867 break;
868 }
869
870 case 's': /* text string or bytes-like object */
871 case 'z': /* text string, bytes-like object or None */
872 {
873 if (*format == '*') {
874 /* "s*" or "z*" */
875 Py_buffer *p = (Py_buffer *)va_arg(*p_va, Py_buffer *);
876
877 if (c == 'z' && arg == Py_None)
878 PyBuffer_FillInfo(p, NULL, NULL, 0, 1, 0);
879 else if (PyUnicode_Check(arg)) {
880 Py_ssize_t len;
881 sarg = PyUnicode_AsUTF8AndSize(arg, &len);
882 if (sarg == NULL)
883 return converterr(CONV_UNICODE,
884 arg, msgbuf, bufsize);
885 PyBuffer_FillInfo(p, arg, (void *)sarg, len, 1, 0);
886 }
887 else { /* any bytes-like object */
888 const char *buf;
889 if (getbuffer(arg, p, &buf) < 0)
890 return converterr(buf, arg, msgbuf, bufsize);
891 }
892 if (addcleanup(p, freelist, cleanup_buffer)) {
893 return converterr(
894 "(cleanup problem)",
895 arg, msgbuf, bufsize);
896 }
897 format++;
898 } else if (*format == '#') { /* a string or read-only bytes-like object */
899 /* "s#" or "z#" */
900 const void **p = (const void **)va_arg(*p_va, const char **);
901 Py_ssize_t *psize = va_arg(*p_va, Py_ssize_t*);
902
903 if (c == 'z' && arg == Py_None) {
904 *p = NULL;
905 *psize = 0;
906 }
907 else if (PyUnicode_Check(arg)) {
908 Py_ssize_t len;
909 sarg = PyUnicode_AsUTF8AndSize(arg, &len);
910 if (sarg == NULL)
911 return converterr(CONV_UNICODE,
912 arg, msgbuf, bufsize);
913 *p = sarg;
914 *psize = len;
915 }
916 else { /* read-only bytes-like object */
917 /* XXX Really? */
918 const char *buf;
919 Py_ssize_t count = convertbuffer(arg, p, &buf);
920 if (count < 0)
921 return converterr(buf, arg, msgbuf, bufsize);
922 *psize = count;
923 }
924 format++;
925 } else {
926 /* "s" or "z" */
927 const char **p = va_arg(*p_va, const char **);
928 Py_ssize_t len;
929 sarg = NULL;
930
931 if (c == 'z' && arg == Py_None)
932 *p = NULL;
933 else if (PyUnicode_Check(arg)) {
934 sarg = PyUnicode_AsUTF8AndSize(arg, &len);
935 if (sarg == NULL)
936 return converterr(CONV_UNICODE,
937 arg, msgbuf, bufsize);
938 if (strlen(sarg) != (size_t)len) {
939 PyErr_SetString(PyExc_ValueError, "embedded null character");
940 RETURN_ERR_OCCURRED;
941 }
942 *p = sarg;
943 }
944 else
945 return converterr(c == 'z' ? "str or None" : "str",
946 arg, msgbuf, bufsize);
947 }
948 break;
949 }
950
951 case 'e': {/* encoded string */
952 char **buffer;
953 const char *encoding;
954 PyObject *s;
955 int recode_strings;
956 Py_ssize_t size;
957 const char *ptr;
958
959 /* Get 'e' parameter: the encoding name */
960 encoding = (const char *)va_arg(*p_va, const char *);
961 if (encoding == NULL)
962 encoding = PyUnicode_GetDefaultEncoding();
963
964 /* Get output buffer parameter:
965 's' (recode all objects via Unicode) or
966 't' (only recode non-string objects)
967 */
968 if (*format == 's')
969 recode_strings = 1;
970 else if (*format == 't')
971 recode_strings = 0;
972 else
973 return converterr(
974 "(unknown parser marker combination)",
975 arg, msgbuf, bufsize);
976 buffer = (char **)va_arg(*p_va, char **);
977 format++;
978 if (buffer == NULL)
979 return converterr("(buffer is NULL)",
980 arg, msgbuf, bufsize);
981
982 /* Encode object */
983 if (!recode_strings &&
984 (PyBytes_Check(arg) || PyByteArray_Check(arg))) {
985 s = Py_NewRef(arg);
986 if (PyBytes_Check(arg)) {
987 size = PyBytes_GET_SIZE(s);
988 ptr = PyBytes_AS_STRING(s);
989 }
990 else {
991 size = PyByteArray_GET_SIZE(s);
992 ptr = PyByteArray_AS_STRING(s);
993 }
994 }
995 else if (PyUnicode_Check(arg)) {
996 /* Encode object; use default error handling */
997 s = PyUnicode_AsEncodedString(arg,
998 encoding,
999 NULL);
1000 if (s == NULL)
1001 return converterr("(encoding failed)",
1002 arg, msgbuf, bufsize);
1003 assert(PyBytes_Check(s));
1004 size = PyBytes_GET_SIZE(s);
1005 ptr = PyBytes_AS_STRING(s);
1006 if (ptr == NULL)
1007 ptr = "";
1008 }
1009 else {
1010 return converterr(
1011 recode_strings ? "str" : "str, bytes or bytearray",
1012 arg, msgbuf, bufsize);
1013 }
1014
1015 /* Write output; output is guaranteed to be 0-terminated */
1016 if (*format == '#') {
1017 /* Using buffer length parameter '#':
1018
1019 - if *buffer is NULL, a new buffer of the
1020 needed size is allocated and the data
1021 copied into it; *buffer is updated to point
1022 to the new buffer; the caller is
1023 responsible for PyMem_Free()ing it after
1024 usage
1025
1026 - if *buffer is not NULL, the data is
1027 copied to *buffer; *buffer_len has to be
1028 set to the size of the buffer on input;
1029 buffer overflow is signalled with an error;
1030 buffer has to provide enough room for the
1031 encoded string plus the trailing 0-byte
1032
1033 - in both cases, *buffer_len is updated to
1034 the size of the buffer /excluding/ the
1035 trailing 0-byte
1036
1037 */
1038 Py_ssize_t *psize = va_arg(*p_va, Py_ssize_t*);
1039
1040 format++;
1041 if (psize == NULL) {
1042 Py_DECREF(s);
1043 return converterr(
1044 "(buffer_len is NULL)",
1045 arg, msgbuf, bufsize);
1046 }
1047 if (*buffer == NULL) {
1048 *buffer = PyMem_NEW(char, size + 1);
1049 if (*buffer == NULL) {
1050 Py_DECREF(s);
1051 PyErr_NoMemory();
1052 RETURN_ERR_OCCURRED;
1053 }
1054 if (addcleanup(buffer, freelist, cleanup_ptr)) {
1055 Py_DECREF(s);
1056 return converterr(
1057 "(cleanup problem)",
1058 arg, msgbuf, bufsize);
1059 }
1060 } else {
1061 if (size + 1 > *psize) {
1062 Py_DECREF(s);
1063 PyErr_Format(PyExc_ValueError,
1064 "encoded string too long "
1065 "(%zd, maximum length %zd)",
1066 (Py_ssize_t)size, (Py_ssize_t)(*psize - 1));
1067 RETURN_ERR_OCCURRED;
1068 }
1069 }
1070 memcpy(*buffer, ptr, size+1);
1071
1072 *psize = size;
1073 }
1074 else {
1075 /* Using a 0-terminated buffer:
1076
1077 - the encoded string has to be 0-terminated
1078 for this variant to work; if it is not, an
1079 error raised
1080
1081 - a new buffer of the needed size is
1082 allocated and the data copied into it;
1083 *buffer is updated to point to the new
1084 buffer; the caller is responsible for
1085 PyMem_Free()ing it after usage
1086
1087 */
1088 if ((Py_ssize_t)strlen(ptr) != size) {
1089 Py_DECREF(s);
1090 return converterr(
1091 "encoded string without null bytes",
1092 arg, msgbuf, bufsize);
1093 }
1094 *buffer = PyMem_NEW(char, size + 1);
1095 if (*buffer == NULL) {
1096 Py_DECREF(s);
1097 PyErr_NoMemory();
1098 RETURN_ERR_OCCURRED;
1099 }
1100 if (addcleanup(buffer, freelist, cleanup_ptr)) {
1101 Py_DECREF(s);
1102 return converterr("(cleanup problem)",
1103 arg, msgbuf, bufsize);
1104 }
1105 memcpy(*buffer, ptr, size+1);
1106 }
1107 Py_DECREF(s);
1108 break;
1109 }
1110
1111 case 'S': { /* PyBytes object */
1112 PyObject **p = va_arg(*p_va, PyObject **);
1113 if (PyBytes_Check(arg))
1114 *p = arg;
1115 else
1116 return converterr("bytes", arg, msgbuf, bufsize);
1117 break;
1118 }
1119
1120 case 'Y': { /* PyByteArray object */
1121 PyObject **p = va_arg(*p_va, PyObject **);
1122 if (PyByteArray_Check(arg))
1123 *p = arg;
1124 else
1125 return converterr("bytearray", arg, msgbuf, bufsize);
1126 break;
1127 }
1128
1129 case 'U': { /* PyUnicode object */
1130 PyObject **p = va_arg(*p_va, PyObject **);
1131 if (PyUnicode_Check(arg)) {
1132 *p = arg;
1133 }
1134 else
1135 return converterr("str", arg, msgbuf, bufsize);
1136 break;
1137 }
1138
1139 case 'O': { /* object */
1140 PyTypeObject *type;
1141 PyObject **p;
1142 if (*format == '!') {
1143 type = va_arg(*p_va, PyTypeObject*);
1144 p = va_arg(*p_va, PyObject **);
1145 format++;
1146 if (PyType_IsSubtype(Py_TYPE(arg), type))
1147 *p = arg;
1148 else
1149 return converterr(type->tp_name, arg, msgbuf, bufsize);
1150
1151 }
1152 else if (*format == '&') {
1153 typedef int (*converter)(PyObject *, void *);
1154 converter convert = va_arg(*p_va, converter);
1155 void *addr = va_arg(*p_va, void *);
1156 int res;
1157 format++;
1158 if (! (res = (*convert)(arg, addr)))
1159 return converterr("(unspecified)",
1160 arg, msgbuf, bufsize);
1161 if (res == Py_CLEANUP_SUPPORTED &&
1162 addcleanup(addr, freelist, convert) == -1)
1163 return converterr("(cleanup problem)",
1164 arg, msgbuf, bufsize);
1165 }
1166 else {
1167 p = va_arg(*p_va, PyObject **);
1168 *p = arg;
1169 }
1170 break;
1171 }
1172
1173
1174 case 'w': { /* "w*": memory buffer, read-write access */
1175 void **p = va_arg(*p_va, void **);
1176
1177 if (*format != '*')
1178 return converterr(
1179 "(invalid use of 'w' format character)",
1180 arg, msgbuf, bufsize);
1181 format++;
1182
1183 /* Caller is interested in Py_buffer, and the object supports it
1184 directly. The request implicitly asks for PyBUF_SIMPLE, so the
1185 result is C-contiguous with format 'B'. */
1186 if (PyObject_GetBuffer(arg, (Py_buffer*)p, PyBUF_WRITABLE) < 0) {
1187 PyErr_Clear();
1188 return converterr("read-write bytes-like object",
1189 arg, msgbuf, bufsize);
1190 }
1191 assert(PyBuffer_IsContiguous((Py_buffer *)p, 'C'));
1192 if (addcleanup(p, freelist, cleanup_buffer)) {
1193 return converterr(
1194 "(cleanup problem)",
1195 arg, msgbuf, bufsize);
1196 }
1197 break;
1198 }
1199
1200 default:
1201 return converterr("(impossible<bad format char>)", arg, msgbuf, bufsize);
1202
1203 }
1204
1205 *p_format = format;
1206 return NULL;
1207
1208 #undef RETURN_ERR_OCCURRED
1209 }
1210
1211 static Py_ssize_t
convertbuffer(PyObject * arg,const void ** p,const char ** errmsg)1212 convertbuffer(PyObject *arg, const void **p, const char **errmsg)
1213 {
1214 PyBufferProcs *pb = Py_TYPE(arg)->tp_as_buffer;
1215 Py_ssize_t count;
1216 Py_buffer view;
1217
1218 *errmsg = NULL;
1219 *p = NULL;
1220 if (pb != NULL && pb->bf_releasebuffer != NULL) {
1221 *errmsg = "read-only bytes-like object";
1222 return -1;
1223 }
1224
1225 if (getbuffer(arg, &view, errmsg) < 0)
1226 return -1;
1227 count = view.len;
1228 *p = view.buf;
1229 PyBuffer_Release(&view);
1230 return count;
1231 }
1232
1233 static int
getbuffer(PyObject * arg,Py_buffer * view,const char ** errmsg)1234 getbuffer(PyObject *arg, Py_buffer *view, const char **errmsg)
1235 {
1236 /* PyBUF_SIMPLE implies C-contiguous */
1237 if (PyObject_GetBuffer(arg, view, PyBUF_SIMPLE) != 0) {
1238 *errmsg = "bytes-like object";
1239 return -1;
1240 }
1241 assert(PyBuffer_IsContiguous(view, 'C'));
1242 return 0;
1243 }
1244
1245 /* Support for keyword arguments donated by
1246 Geoff Philbrick <philbric@delphi.hks.com> */
1247
1248 /* Return false (0) for error, else true. */
1249 int
PyArg_ParseTupleAndKeywords(PyObject * args,PyObject * keywords,const char * format,const char * const * kwlist,...)1250 PyArg_ParseTupleAndKeywords(PyObject *args,
1251 PyObject *keywords,
1252 const char *format,
1253 const char * const *kwlist, ...)
1254 {
1255 int retval;
1256 va_list va;
1257
1258 if ((args == NULL || !PyTuple_Check(args)) ||
1259 (keywords != NULL && !PyDict_Check(keywords)) ||
1260 format == NULL ||
1261 kwlist == NULL)
1262 {
1263 PyErr_BadInternalCall();
1264 return 0;
1265 }
1266
1267 va_start(va, kwlist);
1268 retval = vgetargskeywords(args, keywords, format, kwlist, &va, 0);
1269 va_end(va);
1270 return retval;
1271 }
1272
1273 int
_PyArg_ParseTupleAndKeywords_SizeT(PyObject * args,PyObject * keywords,const char * format,const char * const * kwlist,...)1274 _PyArg_ParseTupleAndKeywords_SizeT(PyObject *args,
1275 PyObject *keywords,
1276 const char *format,
1277 const char * const *kwlist, ...)
1278 {
1279 int retval;
1280 va_list va;
1281
1282 if ((args == NULL || !PyTuple_Check(args)) ||
1283 (keywords != NULL && !PyDict_Check(keywords)) ||
1284 format == NULL ||
1285 kwlist == NULL)
1286 {
1287 PyErr_BadInternalCall();
1288 return 0;
1289 }
1290
1291 va_start(va, kwlist);
1292 retval = vgetargskeywords(args, keywords, format,
1293 kwlist, &va, 0);
1294 va_end(va);
1295 return retval;
1296 }
1297
1298
1299 int
PyArg_VaParseTupleAndKeywords(PyObject * args,PyObject * keywords,const char * format,const char * const * kwlist,va_list va)1300 PyArg_VaParseTupleAndKeywords(PyObject *args,
1301 PyObject *keywords,
1302 const char *format,
1303 const char * const *kwlist, va_list va)
1304 {
1305 int retval;
1306 va_list lva;
1307
1308 if ((args == NULL || !PyTuple_Check(args)) ||
1309 (keywords != NULL && !PyDict_Check(keywords)) ||
1310 format == NULL ||
1311 kwlist == NULL)
1312 {
1313 PyErr_BadInternalCall();
1314 return 0;
1315 }
1316
1317 va_copy(lva, va);
1318
1319 retval = vgetargskeywords(args, keywords, format, kwlist, &lva, 0);
1320 va_end(lva);
1321 return retval;
1322 }
1323
1324 int
_PyArg_VaParseTupleAndKeywords_SizeT(PyObject * args,PyObject * keywords,const char * format,const char * const * kwlist,va_list va)1325 _PyArg_VaParseTupleAndKeywords_SizeT(PyObject *args,
1326 PyObject *keywords,
1327 const char *format,
1328 const char * const *kwlist, va_list va)
1329 {
1330 int retval;
1331 va_list lva;
1332
1333 if ((args == NULL || !PyTuple_Check(args)) ||
1334 (keywords != NULL && !PyDict_Check(keywords)) ||
1335 format == NULL ||
1336 kwlist == NULL)
1337 {
1338 PyErr_BadInternalCall();
1339 return 0;
1340 }
1341
1342 va_copy(lva, va);
1343
1344 retval = vgetargskeywords(args, keywords, format,
1345 kwlist, &lva, 0);
1346 va_end(lva);
1347 return retval;
1348 }
1349
1350 PyAPI_FUNC(int)
_PyArg_ParseTupleAndKeywordsFast(PyObject * args,PyObject * keywords,struct _PyArg_Parser * parser,...)1351 _PyArg_ParseTupleAndKeywordsFast(PyObject *args, PyObject *keywords,
1352 struct _PyArg_Parser *parser, ...)
1353 {
1354 int retval;
1355 va_list va;
1356
1357 va_start(va, parser);
1358 retval = vgetargskeywordsfast(args, keywords, parser, &va, 0);
1359 va_end(va);
1360 return retval;
1361 }
1362
1363 int
_PyArg_ParseTupleAndKeywordsFast_SizeT(PyObject * args,PyObject * keywords,struct _PyArg_Parser * parser,...)1364 _PyArg_ParseTupleAndKeywordsFast_SizeT(PyObject *args, PyObject *keywords,
1365 struct _PyArg_Parser *parser, ...)
1366 {
1367 int retval;
1368 va_list va;
1369
1370 va_start(va, parser);
1371 retval = vgetargskeywordsfast(args, keywords, parser, &va, 0);
1372 va_end(va);
1373 return retval;
1374 }
1375
1376 int
_PyArg_ParseStackAndKeywords(PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames,struct _PyArg_Parser * parser,...)1377 _PyArg_ParseStackAndKeywords(PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames,
1378 struct _PyArg_Parser *parser, ...)
1379 {
1380 int retval;
1381 va_list va;
1382
1383 va_start(va, parser);
1384 retval = vgetargskeywordsfast_impl(args, nargs, NULL, kwnames, parser, &va, 0);
1385 va_end(va);
1386 return retval;
1387 }
1388
1389 int
_PyArg_ParseStackAndKeywords_SizeT(PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames,struct _PyArg_Parser * parser,...)1390 _PyArg_ParseStackAndKeywords_SizeT(PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames,
1391 struct _PyArg_Parser *parser, ...)
1392 {
1393 int retval;
1394 va_list va;
1395
1396 va_start(va, parser);
1397 retval = vgetargskeywordsfast_impl(args, nargs, NULL, kwnames, parser, &va, 0);
1398 va_end(va);
1399 return retval;
1400 }
1401
1402
1403 static void
error_unexpected_keyword_arg(PyObject * kwargs,PyObject * kwnames,PyObject * kwtuple,const char * fname)1404 error_unexpected_keyword_arg(PyObject *kwargs, PyObject *kwnames, PyObject *kwtuple, const char *fname)
1405 {
1406 /* make sure there are no extraneous keyword arguments */
1407 Py_ssize_t j = 0;
1408 while (1) {
1409 PyObject *keyword;
1410 if (kwargs != NULL) {
1411 if (!PyDict_Next(kwargs, &j, &keyword, NULL))
1412 break;
1413 }
1414 else {
1415 if (j >= PyTuple_GET_SIZE(kwnames))
1416 break;
1417 keyword = PyTuple_GET_ITEM(kwnames, j);
1418 j++;
1419 }
1420 if (!PyUnicode_Check(keyword)) {
1421 PyErr_SetString(PyExc_TypeError,
1422 "keywords must be strings");
1423 return;
1424 }
1425
1426 int match = PySequence_Contains(kwtuple, keyword);
1427 if (match <= 0) {
1428 if (!match) {
1429 PyObject *kwlist = PySequence_List(kwtuple);
1430 if (!kwlist) {
1431 return;
1432 }
1433 PyObject *suggestion_keyword = _Py_CalculateSuggestions(kwlist, keyword);
1434 Py_DECREF(kwlist);
1435
1436 if (suggestion_keyword) {
1437 PyErr_Format(PyExc_TypeError,
1438 "%.200s%s got an unexpected keyword argument '%S'."
1439 " Did you mean '%S'?",
1440 (fname == NULL) ? "this function" : fname,
1441 (fname == NULL) ? "" : "()",
1442 keyword,
1443 suggestion_keyword);
1444 Py_DECREF(suggestion_keyword);
1445 }
1446 else {
1447 PyErr_Format(PyExc_TypeError,
1448 "%.200s%s got an unexpected keyword argument '%S'",
1449 (fname == NULL) ? "this function" : fname,
1450 (fname == NULL) ? "" : "()",
1451 keyword);
1452 }
1453
1454 }
1455 return;
1456 }
1457 }
1458 /* Something wrong happened. There are extraneous keyword arguments,
1459 * but we don't know what. And we don't bother. */
1460 PyErr_Format(PyExc_TypeError,
1461 "invalid keyword argument for %.200s%s",
1462 (fname == NULL) ? "this function" : fname,
1463 (fname == NULL) ? "" : "()");
1464 }
1465
1466 int
PyArg_ValidateKeywordArguments(PyObject * kwargs)1467 PyArg_ValidateKeywordArguments(PyObject *kwargs)
1468 {
1469 if (!PyDict_Check(kwargs)) {
1470 PyErr_BadInternalCall();
1471 return 0;
1472 }
1473 if (!_PyDict_HasOnlyStringKeys(kwargs)) {
1474 PyErr_SetString(PyExc_TypeError,
1475 "keywords must be strings");
1476 return 0;
1477 }
1478 return 1;
1479 }
1480
1481 static PyObject *
1482 new_kwtuple(const char * const *keywords, int total, int pos);
1483
1484 #define IS_END_OF_FORMAT(c) (c == '\0' || c == ';' || c == ':')
1485
1486 static int
vgetargskeywords(PyObject * args,PyObject * kwargs,const char * format,const char * const * kwlist,va_list * p_va,int flags)1487 vgetargskeywords(PyObject *args, PyObject *kwargs, const char *format,
1488 const char * const *kwlist, va_list *p_va, int flags)
1489 {
1490 char msgbuf[512];
1491 int levels[32];
1492 const char *fname, *msg, *custom_msg;
1493 int min = INT_MAX;
1494 int max = INT_MAX;
1495 int i, pos, len;
1496 int skip = 0;
1497 Py_ssize_t nargs, nkwargs;
1498 freelistentry_t static_entries[STATIC_FREELIST_ENTRIES];
1499 freelist_t freelist;
1500
1501 freelist.entries = static_entries;
1502 freelist.first_available = 0;
1503 freelist.entries_malloced = 0;
1504
1505 assert(args != NULL && PyTuple_Check(args));
1506 assert(kwargs == NULL || PyDict_Check(kwargs));
1507 assert(format != NULL);
1508 assert(kwlist != NULL);
1509 assert(p_va != NULL);
1510
1511 /* grab the function name or custom error msg first (mutually exclusive) */
1512 fname = strchr(format, ':');
1513 if (fname) {
1514 fname++;
1515 custom_msg = NULL;
1516 }
1517 else {
1518 custom_msg = strchr(format,';');
1519 if (custom_msg)
1520 custom_msg++;
1521 }
1522
1523 /* scan kwlist and count the number of positional-only parameters */
1524 for (pos = 0; kwlist[pos] && !*kwlist[pos]; pos++) {
1525 }
1526 /* scan kwlist and get greatest possible nbr of args */
1527 for (len = pos; kwlist[len]; len++) {
1528 if (!*kwlist[len]) {
1529 PyErr_SetString(PyExc_SystemError,
1530 "Empty keyword parameter name");
1531 return cleanreturn(0, &freelist);
1532 }
1533 }
1534
1535 if (len > STATIC_FREELIST_ENTRIES) {
1536 freelist.entries = PyMem_NEW(freelistentry_t, len);
1537 if (freelist.entries == NULL) {
1538 PyErr_NoMemory();
1539 return 0;
1540 }
1541 freelist.entries_malloced = 1;
1542 }
1543
1544 nargs = PyTuple_GET_SIZE(args);
1545 nkwargs = (kwargs == NULL) ? 0 : PyDict_GET_SIZE(kwargs);
1546 if (nargs + nkwargs > len) {
1547 /* Adding "keyword" (when nargs == 0) prevents producing wrong error
1548 messages in some special cases (see bpo-31229). */
1549 PyErr_Format(PyExc_TypeError,
1550 "%.200s%s takes at most %d %sargument%s (%zd given)",
1551 (fname == NULL) ? "function" : fname,
1552 (fname == NULL) ? "" : "()",
1553 len,
1554 (nargs == 0) ? "keyword " : "",
1555 (len == 1) ? "" : "s",
1556 nargs + nkwargs);
1557 return cleanreturn(0, &freelist);
1558 }
1559
1560 /* convert tuple args and keyword args in same loop, using kwlist to drive process */
1561 for (i = 0; i < len; i++) {
1562 if (*format == '|') {
1563 if (min != INT_MAX) {
1564 PyErr_SetString(PyExc_SystemError,
1565 "Invalid format string (| specified twice)");
1566 return cleanreturn(0, &freelist);
1567 }
1568
1569 min = i;
1570 format++;
1571
1572 if (max != INT_MAX) {
1573 PyErr_SetString(PyExc_SystemError,
1574 "Invalid format string ($ before |)");
1575 return cleanreturn(0, &freelist);
1576 }
1577 }
1578 if (*format == '$') {
1579 if (max != INT_MAX) {
1580 PyErr_SetString(PyExc_SystemError,
1581 "Invalid format string ($ specified twice)");
1582 return cleanreturn(0, &freelist);
1583 }
1584
1585 max = i;
1586 format++;
1587
1588 if (max < pos) {
1589 PyErr_SetString(PyExc_SystemError,
1590 "Empty parameter name after $");
1591 return cleanreturn(0, &freelist);
1592 }
1593 if (skip) {
1594 /* Now we know the minimal and the maximal numbers of
1595 * positional arguments and can raise an exception with
1596 * informative message (see below). */
1597 break;
1598 }
1599 if (max < nargs) {
1600 if (max == 0) {
1601 PyErr_Format(PyExc_TypeError,
1602 "%.200s%s takes no positional arguments",
1603 (fname == NULL) ? "function" : fname,
1604 (fname == NULL) ? "" : "()");
1605 }
1606 else {
1607 PyErr_Format(PyExc_TypeError,
1608 "%.200s%s takes %s %d positional argument%s"
1609 " (%zd given)",
1610 (fname == NULL) ? "function" : fname,
1611 (fname == NULL) ? "" : "()",
1612 (min != INT_MAX) ? "at most" : "exactly",
1613 max,
1614 max == 1 ? "" : "s",
1615 nargs);
1616 }
1617 return cleanreturn(0, &freelist);
1618 }
1619 }
1620 if (IS_END_OF_FORMAT(*format)) {
1621 PyErr_Format(PyExc_SystemError,
1622 "More keyword list entries (%d) than "
1623 "format specifiers (%d)", len, i);
1624 return cleanreturn(0, &freelist);
1625 }
1626 if (!skip) {
1627 PyObject *current_arg;
1628 if (i < nargs) {
1629 current_arg = Py_NewRef(PyTuple_GET_ITEM(args, i));
1630 }
1631 else if (nkwargs && i >= pos) {
1632 if (PyDict_GetItemStringRef(kwargs, kwlist[i], ¤t_arg) < 0) {
1633 return cleanreturn(0, &freelist);
1634 }
1635 if (current_arg) {
1636 --nkwargs;
1637 }
1638 }
1639 else {
1640 current_arg = NULL;
1641 }
1642
1643 if (current_arg) {
1644 msg = convertitem(current_arg, &format, p_va, flags,
1645 levels, msgbuf, sizeof(msgbuf), &freelist);
1646 Py_DECREF(current_arg);
1647 if (msg) {
1648 seterror(i+1, msg, levels, fname, custom_msg);
1649 return cleanreturn(0, &freelist);
1650 }
1651 continue;
1652 }
1653
1654 if (i < min) {
1655 if (i < pos) {
1656 assert (min == INT_MAX);
1657 assert (max == INT_MAX);
1658 skip = 1;
1659 /* At that moment we still don't know the minimal and
1660 * the maximal numbers of positional arguments. Raising
1661 * an exception is deferred until we encounter | and $
1662 * or the end of the format. */
1663 }
1664 else {
1665 PyErr_Format(PyExc_TypeError, "%.200s%s missing required "
1666 "argument '%s' (pos %d)",
1667 (fname == NULL) ? "function" : fname,
1668 (fname == NULL) ? "" : "()",
1669 kwlist[i], i+1);
1670 return cleanreturn(0, &freelist);
1671 }
1672 }
1673 /* current code reports success when all required args
1674 * fulfilled and no keyword args left, with no further
1675 * validation. XXX Maybe skip this in debug build ?
1676 */
1677 if (!nkwargs && !skip) {
1678 return cleanreturn(1, &freelist);
1679 }
1680 }
1681
1682 /* We are into optional args, skip through to any remaining
1683 * keyword args */
1684 msg = skipitem(&format, p_va, flags);
1685 if (msg) {
1686 PyErr_Format(PyExc_SystemError, "%s: '%s'", msg,
1687 format);
1688 return cleanreturn(0, &freelist);
1689 }
1690 }
1691
1692 if (skip) {
1693 PyErr_Format(PyExc_TypeError,
1694 "%.200s%s takes %s %d positional argument%s"
1695 " (%zd given)",
1696 (fname == NULL) ? "function" : fname,
1697 (fname == NULL) ? "" : "()",
1698 (Py_MIN(pos, min) < i) ? "at least" : "exactly",
1699 Py_MIN(pos, min),
1700 Py_MIN(pos, min) == 1 ? "" : "s",
1701 nargs);
1702 return cleanreturn(0, &freelist);
1703 }
1704
1705 if (!IS_END_OF_FORMAT(*format) && (*format != '|') && (*format != '$')) {
1706 PyErr_Format(PyExc_SystemError,
1707 "more argument specifiers than keyword list entries "
1708 "(remaining format:'%s')", format);
1709 return cleanreturn(0, &freelist);
1710 }
1711
1712 if (nkwargs > 0) {
1713 PyObject *key;
1714 Py_ssize_t j;
1715 /* make sure there are no arguments given by name and position */
1716 for (i = pos; i < nargs; i++) {
1717 PyObject *current_arg;
1718 if (PyDict_GetItemStringRef(kwargs, kwlist[i], ¤t_arg) < 0) {
1719 return cleanreturn(0, &freelist);
1720 }
1721 if (current_arg) {
1722 Py_DECREF(current_arg);
1723 /* arg present in tuple and in dict */
1724 PyErr_Format(PyExc_TypeError,
1725 "argument for %.200s%s given by name ('%s') "
1726 "and position (%d)",
1727 (fname == NULL) ? "function" : fname,
1728 (fname == NULL) ? "" : "()",
1729 kwlist[i], i+1);
1730 return cleanreturn(0, &freelist);
1731 }
1732 }
1733 /* make sure there are no extraneous keyword arguments */
1734 j = 0;
1735 while (PyDict_Next(kwargs, &j, &key, NULL)) {
1736 int match = 0;
1737 if (!PyUnicode_Check(key)) {
1738 PyErr_SetString(PyExc_TypeError,
1739 "keywords must be strings");
1740 return cleanreturn(0, &freelist);
1741 }
1742 for (i = pos; i < len; i++) {
1743 if (PyUnicode_EqualToUTF8(key, kwlist[i])) {
1744 match = 1;
1745 break;
1746 }
1747 }
1748 if (!match) {
1749 PyObject *_pykwtuple = new_kwtuple(kwlist, len, pos);
1750 if (!_pykwtuple) {
1751 return cleanreturn(0, &freelist);
1752 }
1753 PyObject *pykwlist = PySequence_List(_pykwtuple);
1754 Py_DECREF(_pykwtuple);
1755 if (!pykwlist) {
1756 return cleanreturn(0, &freelist);
1757 }
1758 PyObject *suggestion_keyword = _Py_CalculateSuggestions(pykwlist, key);
1759 Py_DECREF(pykwlist);
1760
1761 if (suggestion_keyword) {
1762 PyErr_Format(PyExc_TypeError,
1763 "%.200s%s got an unexpected keyword argument '%S'."
1764 " Did you mean '%S'?",
1765 (fname == NULL) ? "this function" : fname,
1766 (fname == NULL) ? "" : "()",
1767 key,
1768 suggestion_keyword);
1769 Py_DECREF(suggestion_keyword);
1770 }
1771 else {
1772 PyErr_Format(PyExc_TypeError,
1773 "%.200s%s got an unexpected keyword argument '%S'",
1774 (fname == NULL) ? "this function" : fname,
1775 (fname == NULL) ? "" : "()",
1776 key);
1777 }
1778 return cleanreturn(0, &freelist);
1779 }
1780 }
1781 /* Something wrong happened. There are extraneous keyword arguments,
1782 * but we don't know what. And we don't bother. */
1783 PyErr_Format(PyExc_TypeError,
1784 "invalid keyword argument for %.200s%s",
1785 (fname == NULL) ? "this function" : fname,
1786 (fname == NULL) ? "" : "()");
1787 return cleanreturn(0, &freelist);
1788 }
1789
1790 return cleanreturn(1, &freelist);
1791 }
1792
1793
1794 static int
scan_keywords(const char * const * keywords,int * ptotal,int * pposonly)1795 scan_keywords(const char * const *keywords, int *ptotal, int *pposonly)
1796 {
1797 /* scan keywords and count the number of positional-only parameters */
1798 int i;
1799 for (i = 0; keywords[i] && !*keywords[i]; i++) {
1800 }
1801 *pposonly = i;
1802
1803 /* scan keywords and get greatest possible nbr of args */
1804 for (; keywords[i]; i++) {
1805 if (!*keywords[i]) {
1806 PyErr_SetString(PyExc_SystemError,
1807 "Empty keyword parameter name");
1808 return -1;
1809 }
1810 }
1811 *ptotal = i;
1812 return 0;
1813 }
1814
1815 static int
parse_format(const char * format,int total,int npos,const char ** pfname,const char ** pcustommsg,int * pmin,int * pmax)1816 parse_format(const char *format, int total, int npos,
1817 const char **pfname, const char **pcustommsg,
1818 int *pmin, int *pmax)
1819 {
1820 /* grab the function name or custom error msg first (mutually exclusive) */
1821 const char *custommsg;
1822 const char *fname = strchr(format, ':');
1823 if (fname) {
1824 fname++;
1825 custommsg = NULL;
1826 }
1827 else {
1828 custommsg = strchr(format,';');
1829 if (custommsg) {
1830 custommsg++;
1831 }
1832 }
1833
1834 int min = INT_MAX;
1835 int max = INT_MAX;
1836 for (int i = 0; i < total; i++) {
1837 if (*format == '|') {
1838 if (min != INT_MAX) {
1839 PyErr_SetString(PyExc_SystemError,
1840 "Invalid format string (| specified twice)");
1841 return -1;
1842 }
1843 if (max != INT_MAX) {
1844 PyErr_SetString(PyExc_SystemError,
1845 "Invalid format string ($ before |)");
1846 return -1;
1847 }
1848 min = i;
1849 format++;
1850 }
1851 if (*format == '$') {
1852 if (max != INT_MAX) {
1853 PyErr_SetString(PyExc_SystemError,
1854 "Invalid format string ($ specified twice)");
1855 return -1;
1856 }
1857 if (i < npos) {
1858 PyErr_SetString(PyExc_SystemError,
1859 "Empty parameter name after $");
1860 return -1;
1861 }
1862 max = i;
1863 format++;
1864 }
1865 if (IS_END_OF_FORMAT(*format)) {
1866 PyErr_Format(PyExc_SystemError,
1867 "More keyword list entries (%d) than "
1868 "format specifiers (%d)", total, i);
1869 return -1;
1870 }
1871
1872 const char *msg = skipitem(&format, NULL, 0);
1873 if (msg) {
1874 PyErr_Format(PyExc_SystemError, "%s: '%s'", msg,
1875 format);
1876 return -1;
1877 }
1878 }
1879 min = Py_MIN(min, total);
1880 max = Py_MIN(max, total);
1881
1882 if (!IS_END_OF_FORMAT(*format) && (*format != '|') && (*format != '$')) {
1883 PyErr_Format(PyExc_SystemError,
1884 "more argument specifiers than keyword list entries "
1885 "(remaining format:'%s')", format);
1886 return -1;
1887 }
1888
1889 *pfname = fname;
1890 *pcustommsg = custommsg;
1891 *pmin = min;
1892 *pmax = max;
1893 return 0;
1894 }
1895
1896 static PyObject *
new_kwtuple(const char * const * keywords,int total,int pos)1897 new_kwtuple(const char * const *keywords, int total, int pos)
1898 {
1899 int nkw = total - pos;
1900 PyObject *kwtuple = PyTuple_New(nkw);
1901 if (kwtuple == NULL) {
1902 return NULL;
1903 }
1904 keywords += pos;
1905 for (int i = 0; i < nkw; i++) {
1906 PyObject *str = PyUnicode_FromString(keywords[i]);
1907 if (str == NULL) {
1908 Py_DECREF(kwtuple);
1909 return NULL;
1910 }
1911 PyInterpreterState *interp = _PyInterpreterState_GET();
1912 _PyUnicode_InternImmortal(interp, &str);
1913 PyTuple_SET_ITEM(kwtuple, i, str);
1914 }
1915 return kwtuple;
1916 }
1917
1918 static int
_parser_init(void * arg)1919 _parser_init(void *arg)
1920 {
1921 struct _PyArg_Parser *parser = (struct _PyArg_Parser *)arg;
1922 const char * const *keywords = parser->keywords;
1923 assert(keywords != NULL);
1924 assert(parser->pos == 0 &&
1925 (parser->format == NULL || parser->fname == NULL) &&
1926 parser->custom_msg == NULL &&
1927 parser->min == 0 &&
1928 parser->max == 0);
1929
1930 int len, pos;
1931 if (scan_keywords(keywords, &len, &pos) < 0) {
1932 return -1;
1933 }
1934
1935 const char *fname, *custommsg = NULL;
1936 int min = 0, max = 0;
1937 if (parser->format) {
1938 assert(parser->fname == NULL);
1939 if (parse_format(parser->format, len, pos,
1940 &fname, &custommsg, &min, &max) < 0) {
1941 return -1;
1942 }
1943 }
1944 else {
1945 assert(parser->fname != NULL);
1946 fname = parser->fname;
1947 }
1948
1949 int owned;
1950 PyObject *kwtuple = parser->kwtuple;
1951 if (kwtuple == NULL) {
1952 /* We may temporarily switch to the main interpreter to avoid
1953 * creating a tuple that could outlive its owning interpreter. */
1954 PyThreadState *save_tstate = NULL;
1955 PyThreadState *temp_tstate = NULL;
1956 if (!_Py_IsMainInterpreter(PyInterpreterState_Get())) {
1957 temp_tstate = PyThreadState_New(_PyInterpreterState_Main());
1958 if (temp_tstate == NULL) {
1959 return -1;
1960 }
1961 save_tstate = PyThreadState_Swap(temp_tstate);
1962 }
1963 kwtuple = new_kwtuple(keywords, len, pos);
1964 if (temp_tstate != NULL) {
1965 PyThreadState_Clear(temp_tstate);
1966 (void)PyThreadState_Swap(save_tstate);
1967 PyThreadState_Delete(temp_tstate);
1968 }
1969 if (kwtuple == NULL) {
1970 return -1;
1971 }
1972 owned = 1;
1973 }
1974 else {
1975 owned = 0;
1976 }
1977
1978 parser->pos = pos;
1979 parser->fname = fname;
1980 parser->custom_msg = custommsg;
1981 parser->min = min;
1982 parser->max = max;
1983 parser->kwtuple = kwtuple;
1984 parser->is_kwtuple_owned = owned;
1985
1986 assert(parser->next == NULL);
1987 parser->next = _Py_atomic_load_ptr(&_PyRuntime.getargs.static_parsers);
1988 do {
1989 // compare-exchange updates parser->next on failure
1990 } while (!_Py_atomic_compare_exchange_ptr(&_PyRuntime.getargs.static_parsers,
1991 &parser->next, parser));
1992 return 0;
1993 }
1994
1995 static int
parser_init(struct _PyArg_Parser * parser)1996 parser_init(struct _PyArg_Parser *parser)
1997 {
1998 return _PyOnceFlag_CallOnce(&parser->once, &_parser_init, parser);
1999 }
2000
2001 static void
parser_clear(struct _PyArg_Parser * parser)2002 parser_clear(struct _PyArg_Parser *parser)
2003 {
2004 if (parser->is_kwtuple_owned) {
2005 Py_CLEAR(parser->kwtuple);
2006 }
2007
2008 if (parser->format) {
2009 parser->fname = NULL;
2010 }
2011 else {
2012 assert(parser->fname != NULL);
2013 }
2014 parser->custom_msg = NULL;
2015 parser->pos = 0;
2016 parser->min = 0;
2017 parser->max = 0;
2018 parser->is_kwtuple_owned = 0;
2019 parser->once.v = 0;
2020 }
2021
2022 static PyObject*
find_keyword(PyObject * kwnames,PyObject * const * kwstack,PyObject * key)2023 find_keyword(PyObject *kwnames, PyObject *const *kwstack, PyObject *key)
2024 {
2025 Py_ssize_t i, nkwargs;
2026
2027 nkwargs = PyTuple_GET_SIZE(kwnames);
2028 for (i = 0; i < nkwargs; i++) {
2029 PyObject *kwname = PyTuple_GET_ITEM(kwnames, i);
2030
2031 /* kwname == key will normally find a match in since keyword keys
2032 should be interned strings; if not retry below in a new loop. */
2033 if (kwname == key) {
2034 return Py_NewRef(kwstack[i]);
2035 }
2036 }
2037
2038 for (i = 0; i < nkwargs; i++) {
2039 PyObject *kwname = PyTuple_GET_ITEM(kwnames, i);
2040 assert(PyUnicode_Check(kwname));
2041 if (_PyUnicode_EQ(kwname, key)) {
2042 return Py_NewRef(kwstack[i]);
2043 }
2044 }
2045 return NULL;
2046 }
2047
2048 static int
vgetargskeywordsfast_impl(PyObject * const * args,Py_ssize_t nargs,PyObject * kwargs,PyObject * kwnames,struct _PyArg_Parser * parser,va_list * p_va,int flags)2049 vgetargskeywordsfast_impl(PyObject *const *args, Py_ssize_t nargs,
2050 PyObject *kwargs, PyObject *kwnames,
2051 struct _PyArg_Parser *parser,
2052 va_list *p_va, int flags)
2053 {
2054 PyObject *kwtuple;
2055 char msgbuf[512];
2056 int levels[32];
2057 const char *format;
2058 const char *msg;
2059 PyObject *keyword;
2060 int i, pos, len;
2061 Py_ssize_t nkwargs;
2062 freelistentry_t static_entries[STATIC_FREELIST_ENTRIES];
2063 freelist_t freelist;
2064 PyObject *const *kwstack = NULL;
2065
2066 freelist.entries = static_entries;
2067 freelist.first_available = 0;
2068 freelist.entries_malloced = 0;
2069
2070 assert(kwargs == NULL || PyDict_Check(kwargs));
2071 assert(kwargs == NULL || kwnames == NULL);
2072 assert(p_va != NULL);
2073
2074 if (parser == NULL) {
2075 PyErr_BadInternalCall();
2076 return 0;
2077 }
2078
2079 if (kwnames != NULL && !PyTuple_Check(kwnames)) {
2080 PyErr_BadInternalCall();
2081 return 0;
2082 }
2083
2084 if (parser_init(parser) < 0) {
2085 return 0;
2086 }
2087
2088 kwtuple = parser->kwtuple;
2089 pos = parser->pos;
2090 len = pos + (int)PyTuple_GET_SIZE(kwtuple);
2091
2092 if (len > STATIC_FREELIST_ENTRIES) {
2093 freelist.entries = PyMem_NEW(freelistentry_t, len);
2094 if (freelist.entries == NULL) {
2095 PyErr_NoMemory();
2096 return 0;
2097 }
2098 freelist.entries_malloced = 1;
2099 }
2100
2101 if (kwargs != NULL) {
2102 nkwargs = PyDict_GET_SIZE(kwargs);
2103 }
2104 else if (kwnames != NULL) {
2105 nkwargs = PyTuple_GET_SIZE(kwnames);
2106 kwstack = args + nargs;
2107 }
2108 else {
2109 nkwargs = 0;
2110 }
2111 if (nargs + nkwargs > len) {
2112 /* Adding "keyword" (when nargs == 0) prevents producing wrong error
2113 messages in some special cases (see bpo-31229). */
2114 PyErr_Format(PyExc_TypeError,
2115 "%.200s%s takes at most %d %sargument%s (%zd given)",
2116 (parser->fname == NULL) ? "function" : parser->fname,
2117 (parser->fname == NULL) ? "" : "()",
2118 len,
2119 (nargs == 0) ? "keyword " : "",
2120 (len == 1) ? "" : "s",
2121 nargs + nkwargs);
2122 return cleanreturn(0, &freelist);
2123 }
2124 if (parser->max < nargs) {
2125 if (parser->max == 0) {
2126 PyErr_Format(PyExc_TypeError,
2127 "%.200s%s takes no positional arguments",
2128 (parser->fname == NULL) ? "function" : parser->fname,
2129 (parser->fname == NULL) ? "" : "()");
2130 }
2131 else {
2132 PyErr_Format(PyExc_TypeError,
2133 "%.200s%s takes %s %d positional argument%s (%zd given)",
2134 (parser->fname == NULL) ? "function" : parser->fname,
2135 (parser->fname == NULL) ? "" : "()",
2136 (parser->min < parser->max) ? "at most" : "exactly",
2137 parser->max,
2138 parser->max == 1 ? "" : "s",
2139 nargs);
2140 }
2141 return cleanreturn(0, &freelist);
2142 }
2143
2144 format = parser->format;
2145 assert(format != NULL || len == 0);
2146 /* convert tuple args and keyword args in same loop, using kwtuple to drive process */
2147 for (i = 0; i < len; i++) {
2148 if (*format == '|') {
2149 format++;
2150 }
2151 if (*format == '$') {
2152 format++;
2153 }
2154 assert(!IS_END_OF_FORMAT(*format));
2155
2156 PyObject *current_arg;
2157 if (i < nargs) {
2158 current_arg = Py_NewRef(args[i]);
2159 }
2160 else if (nkwargs && i >= pos) {
2161 keyword = PyTuple_GET_ITEM(kwtuple, i - pos);
2162 if (kwargs != NULL) {
2163 if (PyDict_GetItemRef(kwargs, keyword, ¤t_arg) < 0) {
2164 return cleanreturn(0, &freelist);
2165 }
2166 }
2167 else {
2168 current_arg = find_keyword(kwnames, kwstack, keyword);
2169 }
2170 if (current_arg) {
2171 --nkwargs;
2172 }
2173 }
2174 else {
2175 current_arg = NULL;
2176 }
2177
2178 if (current_arg) {
2179 msg = convertitem(current_arg, &format, p_va, flags,
2180 levels, msgbuf, sizeof(msgbuf), &freelist);
2181 Py_DECREF(current_arg);
2182 if (msg) {
2183 seterror(i+1, msg, levels, parser->fname, parser->custom_msg);
2184 return cleanreturn(0, &freelist);
2185 }
2186 continue;
2187 }
2188
2189 if (i < parser->min) {
2190 /* Less arguments than required */
2191 if (i < pos) {
2192 Py_ssize_t min = Py_MIN(pos, parser->min);
2193 PyErr_Format(PyExc_TypeError,
2194 "%.200s%s takes %s %d positional argument%s"
2195 " (%zd given)",
2196 (parser->fname == NULL) ? "function" : parser->fname,
2197 (parser->fname == NULL) ? "" : "()",
2198 min < parser->max ? "at least" : "exactly",
2199 min,
2200 min == 1 ? "" : "s",
2201 nargs);
2202 }
2203 else {
2204 keyword = PyTuple_GET_ITEM(kwtuple, i - pos);
2205 PyErr_Format(PyExc_TypeError, "%.200s%s missing required "
2206 "argument '%U' (pos %d)",
2207 (parser->fname == NULL) ? "function" : parser->fname,
2208 (parser->fname == NULL) ? "" : "()",
2209 keyword, i+1);
2210 }
2211 return cleanreturn(0, &freelist);
2212 }
2213 /* current code reports success when all required args
2214 * fulfilled and no keyword args left, with no further
2215 * validation. XXX Maybe skip this in debug build ?
2216 */
2217 if (!nkwargs) {
2218 return cleanreturn(1, &freelist);
2219 }
2220
2221 /* We are into optional args, skip through to any remaining
2222 * keyword args */
2223 msg = skipitem(&format, p_va, flags);
2224 assert(msg == NULL);
2225 }
2226
2227 assert(IS_END_OF_FORMAT(*format) || (*format == '|') || (*format == '$'));
2228
2229 if (nkwargs > 0) {
2230 /* make sure there are no arguments given by name and position */
2231 for (i = pos; i < nargs; i++) {
2232 PyObject *current_arg;
2233 keyword = PyTuple_GET_ITEM(kwtuple, i - pos);
2234 if (kwargs != NULL) {
2235 if (PyDict_GetItemRef(kwargs, keyword, ¤t_arg) < 0) {
2236 return cleanreturn(0, &freelist);
2237 }
2238 }
2239 else {
2240 current_arg = find_keyword(kwnames, kwstack, keyword);
2241 }
2242 if (current_arg) {
2243 Py_DECREF(current_arg);
2244 /* arg present in tuple and in dict */
2245 PyErr_Format(PyExc_TypeError,
2246 "argument for %.200s%s given by name ('%U') "
2247 "and position (%d)",
2248 (parser->fname == NULL) ? "function" : parser->fname,
2249 (parser->fname == NULL) ? "" : "()",
2250 keyword, i+1);
2251 return cleanreturn(0, &freelist);
2252 }
2253 }
2254
2255 error_unexpected_keyword_arg(kwargs, kwnames, kwtuple, parser->fname);
2256 return cleanreturn(0, &freelist);
2257 }
2258
2259 return cleanreturn(1, &freelist);
2260 }
2261
2262 static int
vgetargskeywordsfast(PyObject * args,PyObject * keywords,struct _PyArg_Parser * parser,va_list * p_va,int flags)2263 vgetargskeywordsfast(PyObject *args, PyObject *keywords,
2264 struct _PyArg_Parser *parser, va_list *p_va, int flags)
2265 {
2266 PyObject **stack;
2267 Py_ssize_t nargs;
2268
2269 if (args == NULL
2270 || !PyTuple_Check(args)
2271 || (keywords != NULL && !PyDict_Check(keywords)))
2272 {
2273 PyErr_BadInternalCall();
2274 return 0;
2275 }
2276
2277 stack = _PyTuple_ITEMS(args);
2278 nargs = PyTuple_GET_SIZE(args);
2279 return vgetargskeywordsfast_impl(stack, nargs, keywords, NULL,
2280 parser, p_va, flags);
2281 }
2282
2283
2284 #undef _PyArg_UnpackKeywords
2285
2286 PyObject * const *
_PyArg_UnpackKeywords(PyObject * const * args,Py_ssize_t nargs,PyObject * kwargs,PyObject * kwnames,struct _PyArg_Parser * parser,int minpos,int maxpos,int minkw,PyObject ** buf)2287 _PyArg_UnpackKeywords(PyObject *const *args, Py_ssize_t nargs,
2288 PyObject *kwargs, PyObject *kwnames,
2289 struct _PyArg_Parser *parser,
2290 int minpos, int maxpos, int minkw,
2291 PyObject **buf)
2292 {
2293 PyObject *kwtuple;
2294 PyObject *keyword;
2295 int i, posonly, minposonly, maxargs;
2296 int reqlimit = minkw ? maxpos + minkw : minpos;
2297 Py_ssize_t nkwargs;
2298 PyObject * const *kwstack = NULL;
2299
2300 assert(kwargs == NULL || PyDict_Check(kwargs));
2301 assert(kwargs == NULL || kwnames == NULL);
2302
2303 if (parser == NULL) {
2304 PyErr_BadInternalCall();
2305 return NULL;
2306 }
2307
2308 if (kwnames != NULL && !PyTuple_Check(kwnames)) {
2309 PyErr_BadInternalCall();
2310 return NULL;
2311 }
2312
2313 if (args == NULL && nargs == 0) {
2314 args = buf;
2315 }
2316
2317 if (parser_init(parser) < 0) {
2318 return NULL;
2319 }
2320
2321 kwtuple = parser->kwtuple;
2322 posonly = parser->pos;
2323 minposonly = Py_MIN(posonly, minpos);
2324 maxargs = posonly + (int)PyTuple_GET_SIZE(kwtuple);
2325
2326 if (kwargs != NULL) {
2327 nkwargs = PyDict_GET_SIZE(kwargs);
2328 }
2329 else if (kwnames != NULL) {
2330 nkwargs = PyTuple_GET_SIZE(kwnames);
2331 kwstack = args + nargs;
2332 }
2333 else {
2334 nkwargs = 0;
2335 }
2336 if (nkwargs == 0 && minkw == 0 && minpos <= nargs && nargs <= maxpos) {
2337 /* Fast path. */
2338 return args;
2339 }
2340 if (nargs + nkwargs > maxargs) {
2341 /* Adding "keyword" (when nargs == 0) prevents producing wrong error
2342 messages in some special cases (see bpo-31229). */
2343 PyErr_Format(PyExc_TypeError,
2344 "%.200s%s takes at most %d %sargument%s (%zd given)",
2345 (parser->fname == NULL) ? "function" : parser->fname,
2346 (parser->fname == NULL) ? "" : "()",
2347 maxargs,
2348 (nargs == 0) ? "keyword " : "",
2349 (maxargs == 1) ? "" : "s",
2350 nargs + nkwargs);
2351 return NULL;
2352 }
2353 if (nargs > maxpos) {
2354 if (maxpos == 0) {
2355 PyErr_Format(PyExc_TypeError,
2356 "%.200s%s takes no positional arguments",
2357 (parser->fname == NULL) ? "function" : parser->fname,
2358 (parser->fname == NULL) ? "" : "()");
2359 }
2360 else {
2361 PyErr_Format(PyExc_TypeError,
2362 "%.200s%s takes %s %d positional argument%s (%zd given)",
2363 (parser->fname == NULL) ? "function" : parser->fname,
2364 (parser->fname == NULL) ? "" : "()",
2365 (minpos < maxpos) ? "at most" : "exactly",
2366 maxpos,
2367 (maxpos == 1) ? "" : "s",
2368 nargs);
2369 }
2370 return NULL;
2371 }
2372 if (nargs < minposonly) {
2373 PyErr_Format(PyExc_TypeError,
2374 "%.200s%s takes %s %d positional argument%s"
2375 " (%zd given)",
2376 (parser->fname == NULL) ? "function" : parser->fname,
2377 (parser->fname == NULL) ? "" : "()",
2378 minposonly < maxpos ? "at least" : "exactly",
2379 minposonly,
2380 minposonly == 1 ? "" : "s",
2381 nargs);
2382 return NULL;
2383 }
2384
2385 /* copy tuple args */
2386 for (i = 0; i < nargs; i++) {
2387 buf[i] = args[i];
2388 }
2389
2390 /* copy keyword args using kwtuple to drive process */
2391 for (i = Py_MAX((int)nargs, posonly); i < maxargs; i++) {
2392 PyObject *current_arg;
2393 if (nkwargs) {
2394 keyword = PyTuple_GET_ITEM(kwtuple, i - posonly);
2395 if (kwargs != NULL) {
2396 if (PyDict_GetItemRef(kwargs, keyword, ¤t_arg) < 0) {
2397 return NULL;
2398 }
2399 }
2400 else {
2401 current_arg = find_keyword(kwnames, kwstack, keyword);
2402 }
2403 }
2404 else if (i >= reqlimit) {
2405 break;
2406 }
2407 else {
2408 current_arg = NULL;
2409 }
2410
2411 buf[i] = current_arg;
2412
2413 if (current_arg) {
2414 Py_DECREF(current_arg);
2415 --nkwargs;
2416 }
2417 else if (i < minpos || (maxpos <= i && i < reqlimit)) {
2418 /* Less arguments than required */
2419 keyword = PyTuple_GET_ITEM(kwtuple, i - posonly);
2420 PyErr_Format(PyExc_TypeError, "%.200s%s missing required "
2421 "argument '%U' (pos %d)",
2422 (parser->fname == NULL) ? "function" : parser->fname,
2423 (parser->fname == NULL) ? "" : "()",
2424 keyword, i+1);
2425 return NULL;
2426 }
2427 }
2428
2429 if (nkwargs > 0) {
2430 /* make sure there are no arguments given by name and position */
2431 for (i = posonly; i < nargs; i++) {
2432 PyObject *current_arg;
2433 keyword = PyTuple_GET_ITEM(kwtuple, i - posonly);
2434 if (kwargs != NULL) {
2435 if (PyDict_GetItemRef(kwargs, keyword, ¤t_arg) < 0) {
2436 return NULL;
2437 }
2438 }
2439 else {
2440 current_arg = find_keyword(kwnames, kwstack, keyword);
2441 }
2442 if (current_arg) {
2443 Py_DECREF(current_arg);
2444 /* arg present in tuple and in dict */
2445 PyErr_Format(PyExc_TypeError,
2446 "argument for %.200s%s given by name ('%U') "
2447 "and position (%d)",
2448 (parser->fname == NULL) ? "function" : parser->fname,
2449 (parser->fname == NULL) ? "" : "()",
2450 keyword, i+1);
2451 return NULL;
2452 }
2453 }
2454
2455 error_unexpected_keyword_arg(kwargs, kwnames, kwtuple, parser->fname);
2456 return NULL;
2457 }
2458
2459 return buf;
2460 }
2461
2462 PyObject * const *
_PyArg_UnpackKeywordsWithVararg(PyObject * const * args,Py_ssize_t nargs,PyObject * kwargs,PyObject * kwnames,struct _PyArg_Parser * parser,int minpos,int maxpos,int minkw,int vararg,PyObject ** buf)2463 _PyArg_UnpackKeywordsWithVararg(PyObject *const *args, Py_ssize_t nargs,
2464 PyObject *kwargs, PyObject *kwnames,
2465 struct _PyArg_Parser *parser,
2466 int minpos, int maxpos, int minkw,
2467 int vararg, PyObject **buf)
2468 {
2469 PyObject *kwtuple;
2470 PyObject *keyword;
2471 Py_ssize_t varargssize = 0;
2472 int i, posonly, minposonly, maxargs;
2473 int reqlimit = minkw ? maxpos + minkw : minpos;
2474 Py_ssize_t nkwargs;
2475 PyObject * const *kwstack = NULL;
2476
2477 assert(kwargs == NULL || PyDict_Check(kwargs));
2478 assert(kwargs == NULL || kwnames == NULL);
2479
2480 if (parser == NULL) {
2481 PyErr_BadInternalCall();
2482 return NULL;
2483 }
2484
2485 if (kwnames != NULL && !PyTuple_Check(kwnames)) {
2486 PyErr_BadInternalCall();
2487 return NULL;
2488 }
2489
2490 if (args == NULL && nargs == 0) {
2491 args = buf;
2492 }
2493
2494 if (parser_init(parser) < 0) {
2495 return NULL;
2496 }
2497
2498 kwtuple = parser->kwtuple;
2499 posonly = parser->pos;
2500 minposonly = Py_MIN(posonly, minpos);
2501 maxargs = posonly + (int)PyTuple_GET_SIZE(kwtuple);
2502 if (kwargs != NULL) {
2503 nkwargs = PyDict_GET_SIZE(kwargs);
2504 }
2505 else if (kwnames != NULL) {
2506 nkwargs = PyTuple_GET_SIZE(kwnames);
2507 kwstack = args + nargs;
2508 }
2509 else {
2510 nkwargs = 0;
2511 }
2512 if (nargs < minposonly) {
2513 PyErr_Format(PyExc_TypeError,
2514 "%.200s%s takes %s %d positional argument%s"
2515 " (%zd given)",
2516 (parser->fname == NULL) ? "function" : parser->fname,
2517 (parser->fname == NULL) ? "" : "()",
2518 minposonly < maxpos ? "at least" : "exactly",
2519 minposonly,
2520 minposonly == 1 ? "" : "s",
2521 nargs);
2522 return NULL;
2523 }
2524
2525 /* create varargs tuple */
2526 varargssize = nargs - maxpos;
2527 if (varargssize < 0) {
2528 varargssize = 0;
2529 }
2530 buf[vararg] = PyTuple_New(varargssize);
2531 if (!buf[vararg]) {
2532 return NULL;
2533 }
2534
2535 /* copy tuple args */
2536 for (i = 0; i < nargs; i++) {
2537 if (i >= vararg) {
2538 PyTuple_SET_ITEM(buf[vararg], i - vararg, Py_NewRef(args[i]));
2539 continue;
2540 }
2541 else {
2542 buf[i] = args[i];
2543 }
2544 }
2545
2546 /* copy keyword args using kwtuple to drive process */
2547 for (i = Py_MAX((int)nargs, posonly) - Py_SAFE_DOWNCAST(varargssize, Py_ssize_t, int); i < maxargs; i++) {
2548 PyObject *current_arg;
2549 if (nkwargs) {
2550 keyword = PyTuple_GET_ITEM(kwtuple, i - posonly);
2551 if (kwargs != NULL) {
2552 if (PyDict_GetItemRef(kwargs, keyword, ¤t_arg) < 0) {
2553 goto exit;
2554 }
2555 }
2556 else {
2557 current_arg = find_keyword(kwnames, kwstack, keyword);
2558 }
2559 }
2560 else {
2561 current_arg = NULL;
2562 }
2563
2564 /* If an arguments is passed in as a keyword argument,
2565 * it should be placed before `buf[vararg]`.
2566 *
2567 * For example:
2568 * def f(a, /, b, *args):
2569 * pass
2570 * f(1, b=2)
2571 *
2572 * This `buf` array should be: [1, 2, NULL].
2573 * In this case, nargs < vararg.
2574 *
2575 * Otherwise, we leave a place at `buf[vararg]` for vararg tuple
2576 * so the index is `i + 1`. */
2577 if (i < vararg) {
2578 buf[i] = current_arg;
2579 }
2580 else {
2581 buf[i + 1] = current_arg;
2582 }
2583
2584 if (current_arg) {
2585 Py_DECREF(current_arg);
2586 --nkwargs;
2587 }
2588 else if (i < minpos || (maxpos <= i && i < reqlimit)) {
2589 /* Less arguments than required */
2590 keyword = PyTuple_GET_ITEM(kwtuple, i - posonly);
2591 PyErr_Format(PyExc_TypeError, "%.200s%s missing required "
2592 "argument '%U' (pos %d)",
2593 (parser->fname == NULL) ? "function" : parser->fname,
2594 (parser->fname == NULL) ? "" : "()",
2595 keyword, i+1);
2596 goto exit;
2597 }
2598 }
2599
2600 if (nkwargs > 0) {
2601 error_unexpected_keyword_arg(kwargs, kwnames, kwtuple, parser->fname);
2602 goto exit;
2603 }
2604
2605 return buf;
2606
2607 exit:
2608 Py_XDECREF(buf[vararg]);
2609 return NULL;
2610 }
2611
2612
2613 static const char *
skipitem(const char ** p_format,va_list * p_va,int flags)2614 skipitem(const char **p_format, va_list *p_va, int flags)
2615 {
2616 const char *format = *p_format;
2617 char c = *format++;
2618
2619 switch (c) {
2620
2621 /*
2622 * codes that take a single data pointer as an argument
2623 * (the type of the pointer is irrelevant)
2624 */
2625
2626 case 'b': /* byte -- very short int */
2627 case 'B': /* byte as bitfield */
2628 case 'h': /* short int */
2629 case 'H': /* short int as bitfield */
2630 case 'i': /* int */
2631 case 'I': /* int sized bitfield */
2632 case 'l': /* long int */
2633 case 'k': /* long int sized bitfield */
2634 case 'L': /* long long */
2635 case 'K': /* long long sized bitfield */
2636 case 'n': /* Py_ssize_t */
2637 case 'f': /* float */
2638 case 'd': /* double */
2639 case 'D': /* complex double */
2640 case 'c': /* char */
2641 case 'C': /* unicode char */
2642 case 'p': /* boolean predicate */
2643 case 'S': /* string object */
2644 case 'Y': /* string object */
2645 case 'U': /* unicode string object */
2646 {
2647 if (p_va != NULL) {
2648 (void) va_arg(*p_va, void *);
2649 }
2650 break;
2651 }
2652
2653 /* string codes */
2654
2655 case 'e': /* string with encoding */
2656 {
2657 if (p_va != NULL) {
2658 (void) va_arg(*p_va, const char *);
2659 }
2660 if (!(*format == 's' || *format == 't'))
2661 /* after 'e', only 's' and 't' is allowed */
2662 goto err;
2663 format++;
2664 }
2665 /* fall through */
2666
2667 case 's': /* string */
2668 case 'z': /* string or None */
2669 case 'y': /* bytes */
2670 case 'w': /* buffer, read-write */
2671 {
2672 if (p_va != NULL) {
2673 (void) va_arg(*p_va, char **);
2674 }
2675 if (c == 'w' && *format != '*')
2676 {
2677 /* after 'w', only '*' is allowed */
2678 goto err;
2679 }
2680 if (*format == '#') {
2681 if (p_va != NULL) {
2682 (void) va_arg(*p_va, Py_ssize_t *);
2683 }
2684 format++;
2685 } else if ((c == 's' || c == 'z' || c == 'y' || c == 'w')
2686 && *format == '*')
2687 {
2688 format++;
2689 }
2690 break;
2691 }
2692
2693 case 'O': /* object */
2694 {
2695 if (*format == '!') {
2696 format++;
2697 if (p_va != NULL) {
2698 (void) va_arg(*p_va, PyTypeObject*);
2699 (void) va_arg(*p_va, PyObject **);
2700 }
2701 }
2702 else if (*format == '&') {
2703 typedef int (*converter)(PyObject *, void *);
2704 if (p_va != NULL) {
2705 (void) va_arg(*p_va, converter);
2706 (void) va_arg(*p_va, void *);
2707 }
2708 format++;
2709 }
2710 else {
2711 if (p_va != NULL) {
2712 (void) va_arg(*p_va, PyObject **);
2713 }
2714 }
2715 break;
2716 }
2717
2718 case '(': /* bypass tuple, not handled at all previously */
2719 {
2720 const char *msg;
2721 for (;;) {
2722 if (*format==')')
2723 break;
2724 if (IS_END_OF_FORMAT(*format))
2725 return "Unmatched left paren in format "
2726 "string";
2727 msg = skipitem(&format, p_va, flags);
2728 if (msg)
2729 return msg;
2730 }
2731 format++;
2732 break;
2733 }
2734
2735 case ')':
2736 return "Unmatched right paren in format string";
2737
2738 default:
2739 err:
2740 return "impossible<bad format char>";
2741
2742 }
2743
2744 *p_format = format;
2745 return NULL;
2746 }
2747
2748
2749 #undef _PyArg_CheckPositional
2750
2751 int
_PyArg_CheckPositional(const char * name,Py_ssize_t nargs,Py_ssize_t min,Py_ssize_t max)2752 _PyArg_CheckPositional(const char *name, Py_ssize_t nargs,
2753 Py_ssize_t min, Py_ssize_t max)
2754 {
2755 assert(min >= 0);
2756 assert(min <= max);
2757
2758 if (nargs < min) {
2759 if (name != NULL)
2760 PyErr_Format(
2761 PyExc_TypeError,
2762 "%.200s expected %s%zd argument%s, got %zd",
2763 name, (min == max ? "" : "at least "), min, min == 1 ? "" : "s", nargs);
2764 else
2765 PyErr_Format(
2766 PyExc_TypeError,
2767 "unpacked tuple should have %s%zd element%s,"
2768 " but has %zd",
2769 (min == max ? "" : "at least "), min, min == 1 ? "" : "s", nargs);
2770 return 0;
2771 }
2772
2773 if (nargs == 0) {
2774 return 1;
2775 }
2776
2777 if (nargs > max) {
2778 if (name != NULL)
2779 PyErr_Format(
2780 PyExc_TypeError,
2781 "%.200s expected %s%zd argument%s, got %zd",
2782 name, (min == max ? "" : "at most "), max, max == 1 ? "" : "s", nargs);
2783 else
2784 PyErr_Format(
2785 PyExc_TypeError,
2786 "unpacked tuple should have %s%zd element%s,"
2787 " but has %zd",
2788 (min == max ? "" : "at most "), max, max == 1 ? "" : "s", nargs);
2789 return 0;
2790 }
2791
2792 return 1;
2793 }
2794
2795 static int
unpack_stack(PyObject * const * args,Py_ssize_t nargs,const char * name,Py_ssize_t min,Py_ssize_t max,va_list vargs)2796 unpack_stack(PyObject *const *args, Py_ssize_t nargs, const char *name,
2797 Py_ssize_t min, Py_ssize_t max, va_list vargs)
2798 {
2799 Py_ssize_t i;
2800 PyObject **o;
2801
2802 if (!_PyArg_CheckPositional(name, nargs, min, max)) {
2803 return 0;
2804 }
2805
2806 for (i = 0; i < nargs; i++) {
2807 o = va_arg(vargs, PyObject **);
2808 *o = args[i];
2809 }
2810 return 1;
2811 }
2812
2813 int
PyArg_UnpackTuple(PyObject * args,const char * name,Py_ssize_t min,Py_ssize_t max,...)2814 PyArg_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, ...)
2815 {
2816 PyObject **stack;
2817 Py_ssize_t nargs;
2818 int retval;
2819 va_list vargs;
2820
2821 if (!PyTuple_Check(args)) {
2822 PyErr_SetString(PyExc_SystemError,
2823 "PyArg_UnpackTuple() argument list is not a tuple");
2824 return 0;
2825 }
2826 stack = _PyTuple_ITEMS(args);
2827 nargs = PyTuple_GET_SIZE(args);
2828
2829 va_start(vargs, max);
2830 retval = unpack_stack(stack, nargs, name, min, max, vargs);
2831 va_end(vargs);
2832 return retval;
2833 }
2834
2835 int
_PyArg_UnpackStack(PyObject * const * args,Py_ssize_t nargs,const char * name,Py_ssize_t min,Py_ssize_t max,...)2836 _PyArg_UnpackStack(PyObject *const *args, Py_ssize_t nargs, const char *name,
2837 Py_ssize_t min, Py_ssize_t max, ...)
2838 {
2839 int retval;
2840 va_list vargs;
2841
2842 va_start(vargs, max);
2843 retval = unpack_stack(args, nargs, name, min, max, vargs);
2844 va_end(vargs);
2845 return retval;
2846 }
2847
2848
2849 #undef _PyArg_NoKeywords
2850 #undef _PyArg_NoKwnames
2851 #undef _PyArg_NoPositional
2852
2853 /* For type constructors that don't take keyword args
2854 *
2855 * Sets a TypeError and returns 0 if the args/kwargs is
2856 * not empty, returns 1 otherwise
2857 */
2858 int
_PyArg_NoKeywords(const char * funcname,PyObject * kwargs)2859 _PyArg_NoKeywords(const char *funcname, PyObject *kwargs)
2860 {
2861 if (kwargs == NULL) {
2862 return 1;
2863 }
2864 if (!PyDict_CheckExact(kwargs)) {
2865 PyErr_BadInternalCall();
2866 return 0;
2867 }
2868 if (PyDict_GET_SIZE(kwargs) == 0) {
2869 return 1;
2870 }
2871
2872 PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
2873 funcname);
2874 return 0;
2875 }
2876
2877 int
_PyArg_NoPositional(const char * funcname,PyObject * args)2878 _PyArg_NoPositional(const char *funcname, PyObject *args)
2879 {
2880 if (args == NULL)
2881 return 1;
2882 if (!PyTuple_CheckExact(args)) {
2883 PyErr_BadInternalCall();
2884 return 0;
2885 }
2886 if (PyTuple_GET_SIZE(args) == 0)
2887 return 1;
2888
2889 PyErr_Format(PyExc_TypeError, "%.200s() takes no positional arguments",
2890 funcname);
2891 return 0;
2892 }
2893
2894 int
_PyArg_NoKwnames(const char * funcname,PyObject * kwnames)2895 _PyArg_NoKwnames(const char *funcname, PyObject *kwnames)
2896 {
2897 if (kwnames == NULL) {
2898 return 1;
2899 }
2900
2901 assert(PyTuple_CheckExact(kwnames));
2902
2903 if (PyTuple_GET_SIZE(kwnames) == 0) {
2904 return 1;
2905 }
2906
2907 PyErr_Format(PyExc_TypeError, "%s() takes no keyword arguments", funcname);
2908 return 0;
2909 }
2910
2911 void
_PyArg_Fini(void)2912 _PyArg_Fini(void)
2913 {
2914 struct _PyArg_Parser *tmp, *s = _PyRuntime.getargs.static_parsers;
2915 while (s) {
2916 tmp = s->next;
2917 s->next = NULL;
2918 parser_clear(s);
2919 s = tmp;
2920 }
2921 _PyRuntime.getargs.static_parsers = NULL;
2922 }
2923