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