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