Python/getargs.c

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