Python/getargs.c

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