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