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                 int size, recode_strings;
 898
 899                 /* Get 'e' parameter: the encoding name */
 900                 encoding = (const char *)va_arg(*p_va, const char *);
 901 #ifdef Py_USING_UNICODE
 902                 if (encoding == NULL)
 903                         encoding = PyUnicode_GetDefaultEncoding();
 904 #endif
 905
 906                 /* Get output buffer parameter:
 907                    's' (recode all objects via Unicode) or
 908                    't' (only recode non-string objects)
 909                 */
 910                 if (*format == 's')
 911                         recode_strings = 1;
 912                 else if (*format == 't')
 913                         recode_strings = 0;
 914                 else
 915                         return converterr(
 916                                 "(unknown parser marker combination)",
 917                                 arg, msgbuf, bufsize);
 918                 buffer = (char **)va_arg(*p_va, char **);
 919                 format++;
 920                 if (buffer == NULL)
 921                         return converterr("(buffer is NULL)",
 922                                           arg, msgbuf, bufsize);
 923
 924                 /* Encode object */
 925                 if (!recode_strings && PyString_Check(arg)) {
 926                         s = arg;
 927                         Py_INCREF(s);
 928                 }
 929                 else {
 930 #ifdef Py_USING_UNICODE
 931                         PyObject *u;
 932
 933                         /* Convert object to Unicode */
 934                         u = PyUnicode_FromObject(arg);
 935                         if (u == NULL)
 936                                 return converterr(
 937                                         "string or unicode or text buffer",
 938                                         arg, msgbuf, bufsize);
 939
 940                         /* Encode object; use default error handling */
 941                         s = PyUnicode_AsEncodedString(u,
 942                                                       encoding,
 943                                                       NULL);
 944                         Py_DECREF(u);
 945                         if (s == NULL)
 946                                 return converterr("(encoding failed)",
 947                                                   arg, msgbuf, bufsize);
 948                         if (!PyString_Check(s)) {
 949                                 Py_DECREF(s);
 950                                 return converterr(
 951                                         "(encoder failed to return a string)",
 952                                         arg, msgbuf, bufsize);
 953                         }
 954 #else
 955                         return converterr("string<e>", arg, msgbuf, bufsize);
 956 #endif
 957                 }
 958                 size = PyString_GET_SIZE(s);
 959
 960                 /* Write output; output is guaranteed to be 0-terminated */
 961                 if (*format == '#') {
 962                         /* Using buffer length parameter '#':
 963
 964                            - if *buffer is NULL, a new buffer of the
 965                            needed size is allocated and the data
 966                            copied into it; *buffer is updated to point
 967                            to the new buffer; the caller is
 968                            responsible for PyMem_Free()ing it after
 969                            usage
 970
 971                            - if *buffer is not NULL, the data is
 972                            copied to *buffer; *buffer_len has to be
 973                            set to the size of the buffer on input;
 974                            buffer overflow is signalled with an error;
 975                            buffer has to provide enough room for the
 976                            encoded string plus the trailing 0-byte
 977
 978                            - in both cases, *buffer_len is updated to
 979                            the size of the buffer /excluding/ the
 980                            trailing 0-byte
 981
 982                         */
 983                         FETCH_SIZE;
 984
 985                         format++;
 986                         if (q == NULL && q2 == NULL) {
 987                                 Py_DECREF(s);
 988                                 return converterr(
 989                                         "(buffer_len is NULL)",
 990                                         arg, msgbuf, bufsize);
 991                         }
 992                         if (*buffer == NULL) {
 993                                 *buffer = PyMem_NEW(char, size + 1);
 994                                 if (*buffer == NULL) {
 995                                         Py_DECREF(s);
 996                                         return converterr(
 997                                                 "(memory error)",
 998                                                 arg, msgbuf, bufsize);
 999                                 }
1000                                 if(addcleanup(*buffer, freelist)) {
1001                                         Py_DECREF(s);
1002                                         return converterr(
1003                                                 "(cleanup problem)",
1004                                                 arg, msgbuf, bufsize);
1005                                 }
1006                         } else {
1007                                 if (size + 1 > BUFFER_LEN) {
1008                                         Py_DECREF(s);
1009                                         return converterr(
1010                                                 "(buffer overflow)",
1011                                                 arg, msgbuf, bufsize);
1012                                 }
1013                         }
1014                         memcpy(*buffer,
1015                                PyString_AS_STRING(s),
1016                                size + 1);
1017                         STORE_SIZE(size);
1018                 } else {
1019                         /* Using a 0-terminated buffer:
1020
1021                            - the encoded string has to be 0-terminated
1022                            for this variant to work; if it is not, an
1023                            error raised
1024
1025                            - a new buffer of the needed size is
1026                            allocated and the data copied into it;
1027                            *buffer is updated to point to the new
1028                            buffer; the caller is responsible for
1029                            PyMem_Free()ing it after usage
1030
1031                         */
1032                         if ((Py_ssize_t)strlen(PyString_AS_STRING(s))
1033                                                                 != size) {
1034                                 Py_DECREF(s);
1035                                 return converterr(
1036                                         "(encoded string without NULL bytes)",
1037                                         arg, msgbuf, bufsize);
1038                         }
1039                         *buffer = PyMem_NEW(char, size + 1);
1040                         if (*buffer == NULL) {
1041                                 Py_DECREF(s);
1042                                 return converterr("(memory error)",
1043                                                   arg, msgbuf, bufsize);
1044                         }
1045                         if(addcleanup(*buffer, freelist)) {
1046                                 Py_DECREF(s);
1047                                 return converterr("(cleanup problem)",
1048                                                 arg, msgbuf, bufsize);
1049                         }
1050                         memcpy(*buffer,
1051                                PyString_AS_STRING(s),
1052                                size + 1);
1053                 }
1054                 Py_DECREF(s);
1055                 break;
1056         }
1057
1058 #ifdef Py_USING_UNICODE
1059         case 'u': {/* raw unicode buffer (Py_UNICODE *) */
1060                 if (*format == '#') { /* any buffer-like object */
1061                         void **p = (void **)va_arg(*p_va, char **);
1062                         FETCH_SIZE;
1063                         if (PyUnicode_Check(arg)) {
1064                                 *p = PyUnicode_AS_UNICODE(arg);
1065                                 STORE_SIZE(PyUnicode_GET_SIZE(arg));
1066                         }
1067                         else {
1068                                 return converterr("cannot convert raw buffers",
1069                                                   arg, msgbuf, bufsize);
1070                         }
1071                         format++;
1072                 } else {
1073                         Py_UNICODE **p = va_arg(*p_va, Py_UNICODE **);
1074                         if (PyUnicode_Check(arg))
1075                                 *p = PyUnicode_AS_UNICODE(arg);
1076                         else
1077                                 return converterr("unicode", arg, msgbuf, bufsize);
1078                 }
1079                 break;
1080         }
1081 #endif
1082
1083         case 'S': { /* string object */
1084                 PyObject **p = va_arg(*p_va, PyObject **);
1085                 if (PyString_Check(arg))
1086                         *p = arg;
1087                 else
1088                         return converterr("string", arg, msgbuf, bufsize);
1089                 break;
1090         }
1091
1092 #ifdef Py_USING_UNICODE
1093         case 'U': { /* Unicode object */
1094                 PyObject **p = va_arg(*p_va, PyObject **);
1095                 if (PyUnicode_Check(arg))
1096                         *p = arg;
1097                 else
1098                         return converterr("unicode", arg, msgbuf, bufsize);
1099                 break;
1100         }
1101 #endif
1102
1103         case 'O': { /* object */
1104                 PyTypeObject *type;
1105                 PyObject **p;
1106                 if (*format == '!') {
1107                         type = va_arg(*p_va, PyTypeObject*);
1108                         p = va_arg(*p_va, PyObject **);
1109                         format++;
1110                         if (PyType_IsSubtype(arg->ob_type, type))
1111                                 *p = arg;
1112                         else
1113                                 return converterr(type->tp_name, arg, msgbuf, bufsize);
1114
1115                 }
1116                 else if (*format == '?') {
1117                         inquiry pred = va_arg(*p_va, inquiry);
1118                         p = va_arg(*p_va, PyObject **);
1119                         format++;
1120                         if ((*pred)(arg))
1121                                 *p = arg;
1122                         else
1123                                 return converterr("(unspecified)",
1124                                                   arg, msgbuf, bufsize);
1125
1126                 }
1127                 else if (*format == '&') {
1128                         typedef int (*converter)(PyObject *, void *);
1129                         converter convert = va_arg(*p_va, converter);
1130                         void *addr = va_arg(*p_va, void *);
1131                         format++;
1132                         if (! (*convert)(arg, addr))
1133                                 return converterr("(unspecified)",
1134                                                   arg, msgbuf, bufsize);
1135                 }
1136                 else {
1137                         p = va_arg(*p_va, PyObject **);
1138                         *p = arg;
1139                 }
1140                 break;
1141         }
1142
1143
1144         case 'w': { /* memory buffer, read-write access */
1145                 void **p = va_arg(*p_va, void **);
1146                 PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
1147                 int count;
1148
1149                 if (pb == NULL ||
1150                     pb->bf_getwritebuffer == NULL ||
1151                     pb->bf_getsegcount == NULL)
1152                         return converterr("read-write buffer", arg, msgbuf, bufsize);
1153                 if ((*pb->bf_getsegcount)(arg, NULL) != 1)
1154                         return converterr("single-segment read-write buffer",
1155                                           arg, msgbuf, bufsize);
1156                 if ((count = pb->bf_getwritebuffer(arg, 0, p)) < 0)
1157                         return converterr("(unspecified)", arg, msgbuf, bufsize);
1158                 if (*format == '#') {
1159                         FETCH_SIZE;
1160                         STORE_SIZE(count);
1161                         format++;
1162                 }
1163                 break;
1164         }
1165
1166         case 't': { /* 8-bit character buffer, read-only access */
1167                 char **p = va_arg(*p_va, char **);
1168                 PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
1169                 int count;
1170
1171                 if (*format++ != '#')
1172                         return converterr(
1173                                 "invalid use of 't' format character",
1174                                 arg, msgbuf, bufsize);
1175                 if (!PyType_HasFeature(arg->ob_type,
1176                                        Py_TPFLAGS_HAVE_GETCHARBUFFER) ||
1177                     pb == NULL || pb->bf_getcharbuffer == NULL ||
1178                     pb->bf_getsegcount == NULL)
1179                         return converterr(
1180                                 "string or read-only character buffer",
1181                                 arg, msgbuf, bufsize);
1182
1183                 if (pb->bf_getsegcount(arg, NULL) != 1)
1184                         return converterr(
1185                                 "string or single-segment read-only buffer",
1186                                 arg, msgbuf, bufsize);
1187
1188                 count = pb->bf_getcharbuffer(arg, 0, p);
1189                 if (count < 0)
1190                         return converterr("(unspecified)", arg, msgbuf, bufsize);
1191                 {
1192                         FETCH_SIZE;
1193                         STORE_SIZE(count);
1194                 }
1195                 break;
1196         }
1197
1198         default:
1199                 return converterr("impossible<bad format char>", arg, msgbuf, bufsize);
1200
1201         }
1202
1203         *p_format = format;
1204         return NULL;
1205 }
1206
1207 static Py_ssize_t
1208 convertbuffer(PyObject *arg, void **p, char **errmsg)
1209 {
1210         PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
1211         Py_ssize_t count;
1212         if (pb == NULL ||
1213             pb->bf_getreadbuffer == NULL ||
1214             pb->bf_getsegcount == NULL) {
1215                 *errmsg = "string or read-only buffer";
1216                 return -1;
1217         }
1218         if ((*pb->bf_getsegcount)(arg, NULL) != 1) {
1219                 *errmsg = "string or single-segment read-only buffer";
1220                 return -1;
1221         }
1222         if ((count = (*pb->bf_getreadbuffer)(arg, 0, p)) < 0) {
1223                 *errmsg = "(unspecified)";
1224         }
1225         return count;
1226 }
1227
1228 /* Support for keyword arguments donated by
1229    Geoff Philbrick <philbric@delphi.hks.com> */
1230
1231 /* Return false (0) for error, else true. */
1232 int
1233 PyArg_ParseTupleAndKeywords(PyObject *args,
1234                             PyObject *keywords,
1235                             const char *format,
1236                             char **kwlist, ...)
1237 {
1238         int retval;
1239         va_list va;
1240
1241         if ((args == NULL || !PyTuple_Check(args)) ||
1242             (keywords != NULL && !PyDict_Check(keywords)) ||
1243             format == NULL ||
1244             kwlist == NULL)
1245         {
1246                 PyErr_BadInternalCall();
1247                 return 0;
1248         }
1249
1250         va_start(va, kwlist);
1251         retval = vgetargskeywords(args, keywords, format, kwlist, &va, 0);
1252         va_end(va);
1253         return retval;
1254 }
1255
1256 int
1257 _PyArg_ParseTupleAndKeywords_SizeT(PyObject *args,
1258                                   PyObject *keywords,
1259                                   const char *format,
1260                                   char **kwlist, ...)
1261 {
1262         int retval;
1263         va_list va;
1264
1265         if ((args == NULL || !PyTuple_Check(args)) ||
1266             (keywords != NULL && !PyDict_Check(keywords)) ||
1267             format == NULL ||
1268             kwlist == NULL)
1269         {
1270                 PyErr_BadInternalCall();
1271                 return 0;
1272         }
1273
1274         va_start(va, kwlist);
1275         retval = vgetargskeywords(args, keywords, format,
1276                                   kwlist, &va, FLAG_SIZE_T);
1277         va_end(va);
1278         return retval;
1279 }
1280
1281
1282 int
1283 PyArg_VaParseTupleAndKeywords(PyObject *args,
1284                               PyObject *keywords,
1285                               const char *format,
1286                               char **kwlist, va_list va)
1287 {
1288         int retval;
1289         va_list lva;
1290
1291         if ((args == NULL || !PyTuple_Check(args)) ||
1292             (keywords != NULL && !PyDict_Check(keywords)) ||
1293             format == NULL ||
1294             kwlist == NULL)
1295         {
1296                 PyErr_BadInternalCall();
1297                 return 0;
1298         }
1299
1300 #ifdef VA_LIST_IS_ARRAY
1301         memcpy(lva, va, sizeof(va_list));
1302 #else
1303 #ifdef __va_copy
1304         __va_copy(lva, va);
1305 #else
1306         lva = va;
1307 #endif
1308 #endif
1309
1310         retval = vgetargskeywords(args, keywords, format, kwlist, &lva, 0);
1311         return retval;
1312 }
1313
1314 int
1315 _PyArg_VaParseTupleAndKeywords_SizeT(PyObject *args,
1316                                     PyObject *keywords,
1317                                     const char *format,
1318                                     char **kwlist, va_list va)
1319 {
1320         int retval;
1321         va_list lva;
1322
1323         if ((args == NULL || !PyTuple_Check(args)) ||
1324             (keywords != NULL && !PyDict_Check(keywords)) ||
1325             format == NULL ||
1326             kwlist == NULL)
1327         {
1328                 PyErr_BadInternalCall();
1329                 return 0;
1330         }
1331
1332 #ifdef VA_LIST_IS_ARRAY
1333         memcpy(lva, va, sizeof(va_list));
1334 #else
1335 #ifdef __va_copy
1336         __va_copy(lva, va);
1337 #else
1338         lva = va;
1339 #endif
1340 #endif
1341
1342         retval = vgetargskeywords(args, keywords, format,
1343                                   kwlist, &lva, FLAG_SIZE_T);
1344         return retval;
1345 }
1346
1347
1348 static int
1349 vgetargskeywords(PyObject *args, PyObject *keywords, const char *format,
1350                  char **kwlist, va_list *p_va, int flags)
1351 {
1352         char msgbuf[512];
1353         int levels[32];
1354         const char *fname, *message;
1355         int min, max;
1356         const char *formatsave;
1357         int i, len, nargs, nkeywords;
1358         const char *msg;
1359         char **p;
1360         PyObject *freelist = NULL;
1361
1362         assert(args != NULL && PyTuple_Check(args));
1363         assert(keywords == NULL || PyDict_Check(keywords));
1364         assert(format != NULL);
1365         assert(kwlist != NULL);
1366         assert(p_va != NULL);
1367
1368         /* Search the format:
1369            message <- error msg, if any (else NULL).
1370            fname <- routine name, if any (else NULL).
1371            min <- # of required arguments, or -1 if all are required.
1372            max <- most arguments (required + optional).
1373            Check that kwlist has a non-NULL entry for each arg.
1374            Raise error if a tuple arg spec is found.
1375         */
1376         fname = message = NULL;
1377         formatsave = format;
1378         p = kwlist;
1379         min = -1;
1380         max = 0;
1381         while ((i = *format++) != '\0') {
1382                 if (isalpha(Py_CHARMASK(i)) && i != 'e') {
1383                         max++;
1384                         if (*p == NULL) {
1385                                 PyErr_SetString(PyExc_RuntimeError,
1386                                         "more argument specifiers than "
1387                                         "keyword list entries");
1388                                 return 0;
1389                         }
1390                         p++;
1391                 }
1392                 else if (i == '|')
1393                         min = max;
1394                 else if (i == ':') {
1395                         fname = format;
1396                         break;
1397                 }
1398                 else if (i == ';') {
1399                         message = format;
1400                         break;
1401                 }
1402                 else if (i == '(') {
1403                         PyErr_SetString(PyExc_RuntimeError,
1404                                 "tuple found in format when using keyword "
1405                                 "arguments");
1406                         return 0;
1407                 }
1408         }
1409         format = formatsave;
1410         if (*p != NULL) {
1411                 PyErr_SetString(PyExc_RuntimeError,
1412                         "more keyword list entries than "
1413                         "argument specifiers");
1414                 return 0;
1415         }
1416         if (min < 0) {
1417                 /* All arguments are required. */
1418                 min = max;
1419         }
1420
1421         nargs = PyTuple_GET_SIZE(args);
1422         nkeywords = keywords == NULL ? 0 : PyDict_Size(keywords);
1423
1424         /* make sure there are no duplicate values for an argument;
1425            its not clear when to use the term "keyword argument vs.
1426            keyword parameter in messages */
1427         if (nkeywords > 0) {
1428                 for (i = 0; i < nargs; i++) {
1429                         const char *thiskw = kwlist[i];
1430                         if (thiskw == NULL)
1431                                 break;
1432                         if (PyDict_GetItemString(keywords, thiskw)) {
1433                                 PyErr_Format(PyExc_TypeError,
1434                                         "keyword parameter '%s' was given "
1435                                         "by position and by name",
1436                                         thiskw);
1437                                 return 0;
1438                         }
1439                         else if (PyErr_Occurred())
1440                                 return 0;
1441                 }
1442         }
1443
1444         /* required arguments missing from args can be supplied by keyword
1445            arguments; set len to the number of positional arguments, and,
1446            if that's less than the minimum required, add in the number of
1447            required arguments that are supplied by keywords */
1448         len = nargs;
1449         if (nkeywords > 0 && nargs < min) {
1450                 for (i = nargs; i < min; i++) {
1451                         if (PyDict_GetItemString(keywords, kwlist[i]))
1452                                 len++;
1453                         else if (PyErr_Occurred())
1454                                 return 0;
1455                 }
1456         }
1457
1458         /* make sure we got an acceptable number of arguments; the message
1459            is a little confusing with keywords since keyword arguments
1460            which are supplied, but don't match the required arguments
1461            are not included in the "%d given" part of the message
1462            XXX and this isn't a bug!? */
1463         if (len < min || max < len) {
1464                 if (message == NULL) {
1465                         PyOS_snprintf(msgbuf, sizeof(msgbuf),
1466                                       "%.200s%s takes %s %d argument%s "
1467                                       "(%d given)",
1468                                       fname==NULL ? "function" : fname,
1469                                       fname==NULL ? "" : "()",
1470                                       min==max ? "exactly"
1471                                       : len < min ? "at least" : "at most",
1472                                       len < min ? min : max,
1473                                       (len < min ? min : max) == 1 ? "" : "s",
1474                                       len);
1475                         message = msgbuf;
1476                 }
1477                 PyErr_SetString(PyExc_TypeError, message);
1478                 return 0;
1479         }
1480
1481         /* convert the positional arguments */
1482         for (i = 0; i < nargs; i++) {
1483                 if (*format == '|')
1484                         format++;
1485                 msg = convertitem(PyTuple_GET_ITEM(args, i), &format, p_va,
1486                                   flags, levels, msgbuf, sizeof(msgbuf),
1487                                   &freelist);
1488                 if (msg) {
1489                         seterror(i+1, msg, levels, fname, message);
1490                         return cleanreturn(0, freelist);
1491                 }
1492         }
1493
1494         /* handle no keyword parameters in call */
1495         if (nkeywords == 0)
1496                 return cleanreturn(1, freelist);
1497
1498         /* convert the keyword arguments; this uses the format
1499            string where it was left after processing args */
1500         for (i = nargs; i < max; i++) {
1501                 PyObject *item;
1502                 if (*format == '|')
1503                         format++;
1504                 item = PyDict_GetItemString(keywords, kwlist[i]);
1505                 if (item != NULL) {
1506                         Py_INCREF(item);
1507                         msg = convertitem(item, &format, p_va, flags, levels,
1508                                           msgbuf, sizeof(msgbuf), &freelist);
1509                         Py_DECREF(item);
1510                         if (msg) {
1511                                 seterror(i+1, msg, levels, fname, message);
1512                                 return cleanreturn(0, freelist);
1513                         }
1514                         --nkeywords;
1515                         if (nkeywords == 0)
1516                                 break;
1517                 }
1518                 else if (PyErr_Occurred())
1519                         return cleanreturn(0, freelist);
1520                 else {
1521                         msg = skipitem(&format, p_va, flags);
1522                         if (msg) {
1523                                 levels[0] = 0;
1524                                 seterror(i+1, msg, levels, fname, message);
1525                                 return cleanreturn(0, freelist);
1526                         }
1527                 }
1528         }
1529
1530         /* make sure there are no extraneous keyword arguments */
1531         if (nkeywords > 0) {
1532                 PyObject *key, *value;
1533                 Py_ssize_t pos = 0;
1534                 while (PyDict_Next(keywords, &pos, &key, &value)) {
1535                         int match = 0;
1536                         char *ks;
1537                         if (!PyString_Check(key)) {
1538                                 PyErr_SetString(PyExc_TypeError,
1539                                                 "keywords must be strings");
1540                                 return cleanreturn(0, freelist);
1541                         }
1542                         ks = PyString_AsString(key);
1543                         for (i = 0; i < max; i++) {
1544                                 if (!strcmp(ks, kwlist[i])) {
1545                                         match = 1;
1546                                         break;
1547                                 }
1548                         }
1549                         if (!match) {
1550                                 PyErr_Format(PyExc_TypeError,
1551                                              "'%s' is an invalid keyword "
1552                                              "argument for this function",
1553                                              ks);
1554                                 return cleanreturn(0, freelist);
1555                         }
1556                 }
1557         }
1558
1559         return cleanreturn(1, freelist);
1560 }
1561
1562
1563 static char *
1564 skipitem(const char **p_format, va_list *p_va, int flags)
1565 {
1566         const char *format = *p_format;
1567         char c = *format++;
1568
1569         switch (c) {
1570
1571         /* simple codes
1572          * The individual types (second arg of va_arg) are irrelevant */
1573
1574         case 'b': /* byte -- very short int */
1575         case 'B': /* byte as bitfield */
1576         case 'h': /* short int */
1577         case 'H': /* short int as bitfield */
1578         case 'i': /* int */
1579         case 'I': /* int sized bitfield */
1580         case 'l': /* long int */
1581         case 'k': /* long int sized bitfield */
1582 #ifdef HAVE_LONG_LONG
1583         case 'L': /* PY_LONG_LONG */
1584         case 'K': /* PY_LONG_LONG sized bitfield */
1585 #endif
1586         case 'f': /* float */
1587         case 'd': /* double */
1588 #ifndef WITHOUT_COMPLEX
1589         case 'D': /* complex double */
1590 #endif
1591         case 'c': /* char */
1592                 {
1593                         (void) va_arg(*p_va, void *);
1594                         break;
1595                 }
1596
1597         case 'n': /* Py_ssize_t */
1598                 {
1599                         (void) va_arg(*p_va, Py_ssize_t *);
1600                         break;
1601                 }
1602
1603         /* string codes */
1604
1605         case 'e': /* string with encoding */
1606                 {
1607                         (void) va_arg(*p_va, const char *);
1608                         if (!(*format == 's' || *format == 't'))
1609                                 /* after 'e', only 's' and 't' is allowed */
1610                                 goto err;
1611                         format++;
1612                         /* explicit fallthrough to string cases */
1613                 }
1614
1615         case 's': /* string */
1616         case 'z': /* string or None */
1617 #ifdef Py_USING_UNICODE
1618         case 'u': /* unicode string */
1619 #endif
1620         case 't': /* buffer, read-only */
1621         case 'w': /* buffer, read-write */
1622                 {
1623                         (void) va_arg(*p_va, char **);
1624                         if (*format == '#') {
1625                                 if (flags & FLAG_SIZE_T)
1626                                         (void) va_arg(*p_va, Py_ssize_t *);
1627                                 else
1628                                         (void) va_arg(*p_va, int *);
1629                                 format++;
1630                         }
1631                         break;
1632                 }
1633
1634         /* object codes */
1635
1636         case 'S': /* string object */
1637 #ifdef Py_USING_UNICODE
1638         case 'U': /* unicode string object */
1639 #endif
1640                 {
1641                         (void) va_arg(*p_va, PyObject **);
1642                         break;
1643                 }
1644
1645         case 'O': /* object */
1646                 {
1647                         if (*format == '!') {
1648                                 format++;
1649                                 (void) va_arg(*p_va, PyTypeObject*);
1650                                 (void) va_arg(*p_va, PyObject **);
1651                         }
1652 #if 0
1653 /* I don't know what this is for */
1654                         else if (*format == '?') {
1655                                 inquiry pred = va_arg(*p_va, inquiry);
1656                                 format++;
1657                                 if ((*pred)(arg)) {
1658                                         (void) va_arg(*p_va, PyObject **);
1659                                 }
1660                         }
1661 #endif
1662                         else if (*format == '&') {
1663                                 typedef int (*converter)(PyObject *, void *);
1664                                 (void) va_arg(*p_va, converter);
1665                                 (void) va_arg(*p_va, void *);
1666                                 format++;
1667                         }
1668                         else {
1669                                 (void) va_arg(*p_va, PyObject **);
1670                         }
1671                         break;
1672                 }
1673
1674         default:
1675 err:
1676                 return "impossible<bad format char>";
1677
1678         }
1679
1680         /* The "(...)" format code for tuples is not handled here because
1681          * it is not allowed with keyword args. */
1682
1683         *p_format = format;
1684         return NULL;
1685 }
1686
1687
1688 int
1689 PyArg_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, ...)
1690 {
1691         Py_ssize_t i, l;
1692         PyObject **o;
1693         va_list vargs;
1694
1695 #ifdef HAVE_STDARG_PROTOTYPES
1696         va_start(vargs, max);
1697 #else
1698         va_start(vargs);
1699 #endif
1700
1701         assert(min >= 0);
1702         assert(min <= max);
1703         if (!PyTuple_Check(args)) {
1704                 PyErr_SetString(PyExc_SystemError,
1705                     "PyArg_UnpackTuple() argument list is not a tuple");
1706                 return 0;
1707         }
1708         l = PyTuple_GET_SIZE(args);
1709         if (l < min) {
1710                 if (name != NULL)
1711                         PyErr_Format(
1712                             PyExc_TypeError,
1713                             "%s expected %s%zd arguments, got %zd",
1714                             name, (min == max ? "" : "at least "), min, l);
1715                 else
1716                         PyErr_Format(
1717                             PyExc_TypeError,
1718                             "unpacked tuple should have %s%zd elements,"
1719                             " but has %zd",
1720                             (min == max ? "" : "at least "), min, l);
1721                 va_end(vargs);
1722                 return 0;
1723         }
1724         if (l > max) {
1725                 if (name != NULL)
1726                         PyErr_Format(
1727                             PyExc_TypeError,
1728                             "%s expected %s%zd arguments, got %zd",
1729                             name, (min == max ? "" : "at most "), max, l);
1730                 else
1731                         PyErr_Format(
1732                             PyExc_TypeError,
1733                             "unpacked tuple should have %s%zd elements,"
1734                             " but has %zd",
1735                             (min == max ? "" : "at most "), max, l);
1736                 va_end(vargs);
1737                 return 0;
1738         }
1739         for (i = 0; i < l; i++) {
1740                 o = va_arg(vargs, PyObject **);
1741                 *o = PyTuple_GET_ITEM(args, i);
1742         }
1743         va_end(vargs);
1744         return 1;
1745 }
1746
1747
1748 /* For type constructors that don't take keyword args
1749  *
1750  * Sets a TypeError and returns 0 if the kwds dict is
1751  * not empty, returns 1 otherwise
1752  */
1753 int
1754 _PyArg_NoKeywords(const char *funcname, PyObject *kw)
1755 {
1756         if (kw == NULL)
1757                 return 1;
1758         if (!PyDict_CheckExact(kw)) {
1759                 PyErr_BadInternalCall();
1760                 return 0;
1761         }
1762         if (PyDict_Size(kw) == 0)
1763                 return 1;
1764
1765         PyErr_Format(PyExc_TypeError, "%s does not take keyword arguments",
1766                         funcname);
1767         return 0;
1768 }
1769 #ifdef __cplusplus
1770 };
1771 #endif