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