Python/getargs.c

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