Python/getargs.c

   1 /***********************************************************
   2 Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
   3 The Netherlands.
   4
   5                         All Rights Reserved
   6
   7 Permission to use, copy, modify, and distribute this software and its
   8 documentation for any purpose and without fee is hereby granted,
   9 provided that the above copyright notice appear in all copies and that
  10 both that copyright notice and this permission notice appear in
  11 supporting documentation, and that the names of Stichting Mathematisch
  12 Centrum or CWI or Corporation for National Research Initiatives or
  13 CNRI not be used in advertising or publicity pertaining to
  14 distribution of the software without specific, written prior
  15 permission.
  16
  17 While CWI is the initial source for this software, a modified version
  18 is made available by the Corporation for National Research Initiatives
  19 (CNRI) at the Internet address ftp://ftp.python.org.
  20
  21 STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
  22 REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
  23 MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
  24 CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  25 DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  26 PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  27 TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  28 PERFORMANCE OF THIS SOFTWARE.
  29
  30 ******************************************************************/
  31
  32 /* New getargs implementation */
  33
  34 /* XXX There are several unchecked sprintf or strcat calls in this file.
  35    XXX The only way these can become a danger is if some C code in the
  36    XXX Python source (or in an extension) uses ridiculously long names
  37    XXX or riduculously deep nesting in format strings. */
  38
  39 #include "Python.h"
  40
  41 #include <ctype.h>
  42
  43
  44 int PyArg_Parse Py_PROTO((PyObject *, char *, ...));
  45 int PyArg_ParseTuple Py_PROTO((PyObject *, char *, ...));
  46 int PyArg_VaParse Py_PROTO((PyObject *, char *, va_list));
  47
  48 int PyArg_ParseTupleAndKeywords Py_PROTO((PyObject *, PyObject *,
  49                                        char *, char **, ...));
  50
  51 /* Forward */
  52 static int vgetargs1 Py_PROTO((PyObject *, char *, va_list *, int));
  53 static void seterror Py_PROTO((int, char *, int *, char *, char *));
  54 static char *convertitem Py_PROTO((PyObject *, char **, va_list *,
  55                                    int *, char *));
  56 static char *converttuple Py_PROTO((PyObject *, char **, va_list *,
  57                                  int *, char *, int));
  58 static char *convertsimple Py_PROTO((PyObject *, char **, va_list *, char *));
  59 static char *convertsimple1 Py_PROTO((PyObject *, char **, va_list *));
  60
  61 static int vgetargskeywords Py_PROTO((PyObject *, PyObject *,
  62                                    char *, char **, va_list *));
  63 static char *skipitem Py_PROTO((char **, va_list *));
  64
  65 #ifdef HAVE_STDARG_PROTOTYPES
  66 /* VARARGS2 */
  67 int PyArg_Parse(PyObject *args, char *format, ...)
  68 #else
  69 /* VARARGS */
  70 int PyArg_Parse(va_alist) va_dcl
  71 #endif
  72 {
  73         int retval;
  74         va_list va;
  75 #ifdef HAVE_STDARG_PROTOTYPES
  76
  77         va_start(va, format);
  78 #else
  79         PyObject *args;
  80         char *format;
  81
  82         va_start(va);
  83         args = va_arg(va, PyObject *);
  84         format = va_arg(va, char *);
  85 #endif
  86         retval = vgetargs1(args, format, &va, 1);
  87         va_end(va);
  88         return retval;
  89 }
  90
  91
  92 #ifdef HAVE_STDARG_PROTOTYPES
  93 /* VARARGS2 */
  94 int PyArg_ParseTuple(PyObject *args, char *format, ...)
  95 #else
  96 /* VARARGS */
  97 int PyArg_ParseTuple(va_alist) va_dcl
  98 #endif
  99 {
 100         int retval;
 101         va_list va;
 102 #ifdef HAVE_STDARG_PROTOTYPES
 103
 104         va_start(va, format);
 105 #else
 106         PyObject *args;
 107         char *format;
 108
 109         va_start(va);
 110         args = va_arg(va, PyObject *);
 111         format = va_arg(va, char *);
 112 #endif
 113         retval = vgetargs1(args, format, &va, 0);
 114         va_end(va);
 115         return retval;
 116 }
 117
 118
 119 int
 120 PyArg_VaParse(args, format, va)
 121         PyObject *args;
 122         char *format;
 123         va_list va;
 124 {
 125         va_list lva;
 126
 127 #ifdef VA_LIST_IS_ARRAY
 128         memcpy(lva, va, sizeof(va_list));
 129 #else
 130         lva = va;
 131 #endif
 132
 133         return vgetargs1(args, format, &lva, 0);
 134 }
 135
 136
 137 static int
 138 vgetargs1(args, format, p_va, compat)
 139         PyObject *args;
 140         char *format;
 141         va_list *p_va;
 142         int compat;
 143 {
 144         char msgbuf[256];
 145         int levels[32];
 146         char *fname = NULL;
 147         char *message = NULL;
 148         int min = -1;
 149         int max = 0;
 150         int level = 0;
 151         char *formatsave = format;
 152         int i, len;
 153         char *msg;
 154
 155         for (;;) {
 156                 int c = *format++;
 157                 if (c == '(' /* ')' */) {
 158                         if (level == 0)
 159                                 max++;
 160                         level++;
 161                 }
 162                 else if (/* '(' */ c == ')') {
 163                         if (level == 0)
 164                                 Py_FatalError(/* '(' */
 165                                       "excess ')' in getargs format");
 166                         else
 167                                 level--;
 168                 }
 169                 else if (c == '\0')
 170                         break;
 171                 else if (c == ':') {
 172                         fname = format;
 173                         break;
 174                 }
 175                 else if (c == ';') {
 176                         message = format;
 177                         break;
 178                 }
 179                 else if (level != 0)
 180                         ; /* Pass */
 181                 else if (isalpha(c))
 182                         max++;
 183                 else if (c == '|')
 184                         min = max;
 185         }
 186
 187         if (level != 0)
 188                 Py_FatalError(/* '(' */ "missing ')' in getargs format");
 189
 190         if (min < 0)
 191                 min = max;
 192
 193         format = formatsave;
 194
 195         if (compat) {
 196                 if (max == 0) {
 197                         if (args == NULL)
 198                                 return 1;
 199                         sprintf(msgbuf, "%s requires no arguments",
 200                                 fname==NULL ? "function" : fname);
 201                         PyErr_SetString(PyExc_TypeError, msgbuf);
 202                         return 0;
 203                 }
 204                 else if (min == 1 && max == 1) {
 205                         if (args == NULL) {
 206                                 sprintf(msgbuf,
 207                                         "%s requires at least one argument",
 208                                         fname==NULL ? "function" : fname);
 209                                 PyErr_SetString(PyExc_TypeError, msgbuf);
 210                                 return 0;
 211                         }
 212                         msg = convertitem(args, &format, p_va, levels, msgbuf);
 213                         if (msg == NULL)
 214                                 return 1;
 215                         seterror(levels[0], msg, levels+1, fname, message);
 216                         return 0;
 217                 }
 218                 else {
 219                         PyErr_SetString(PyExc_SystemError,
 220                             "old style getargs format uses new features");
 221                         return 0;
 222                 }
 223         }
 224
 225         if (!PyTuple_Check(args)) {
 226                 PyErr_SetString(PyExc_SystemError,
 227                     "new style getargs format but argument is not a tuple");
 228                 return 0;
 229         }
 230
 231         len = PyTuple_Size(args);
 232
 233         if (len < min || max < len) {
 234                 if (message == NULL) {
 235                         sprintf(msgbuf,
 236                                 "%s requires %s %d argument%s; %d given",
 237                                 fname==NULL ? "function" : fname,
 238                                 min==max ? "exactly"
 239                                          : len < min ? "at least" : "at most",
 240                                 len < min ? min : max,
 241                                 (len < min ? min : max) == 1 ? "" : "s",
 242                                 len);
 243                         message = msgbuf;
 244                 }
 245                 PyErr_SetString(PyExc_TypeError, message);
 246                 return 0;
 247         }
 248
 249         for (i = 0; i < len; i++) {
 250                 if (*format == '|')
 251                         format++;
 252                 msg = convertitem(PyTuple_GetItem(args, i), &format, p_va,
 253                                  levels, msgbuf);
 254                 if (msg) {
 255                         seterror(i+1, msg, levels, fname, message);
 256                         return 0;
 257                 }
 258         }
 259
 260         if (*format != '\0' && !isalpha((int)(*format)) &&
 261             *format != '(' &&
 262             *format != '|' && *format != ':' && *format != ';') {
 263                 PyErr_Format(PyExc_SystemError,
 264                              "bad format string: %.200s", formatsave);
 265                 return 0;
 266         }
 267
 268         return 1;
 269 }
 270
 271
 272
 273 static void
 274 seterror(iarg, msg, levels, fname, message)
 275         int iarg;
 276         char *msg;
 277         int *levels;
 278         char *fname;
 279         char *message;
 280 {
 281         char buf[256];
 282         int i;
 283         char *p = buf;
 284
 285         if (PyErr_Occurred())
 286                 return;
 287         if (iarg == 0 && message == NULL)
 288                 message = msg;
 289         else if (message == NULL) {
 290                 if (fname != NULL) {
 291                         sprintf(p, "%s, ", fname);
 292                         p += strlen(p);
 293                 }
 294                 sprintf(p, "argument %d", iarg);
 295                 i = 0;
 296                 p += strlen(p);
 297                 while (levels[i] > 0) {
 298                         sprintf(p, ", item %d", levels[i]-1);
 299                         p += strlen(p);
 300                         i++;
 301                 }
 302                 sprintf(p, ": expected %s found", msg);
 303                 message = buf;
 304         }
 305         PyErr_SetString(PyExc_TypeError, message);
 306 }
 307
 308
 309 /* Convert a tuple argument.
 310    On entry, *p_format points to the character _after_ the opening '('.
 311    On successful exit, *p_format points to the closing ')'.
 312    If successful:
 313       *p_format and *p_va are updated,
 314       *levels and *msgbuf are untouched,
 315       and NULL is returned.
 316    If the argument is invalid:
 317       *p_format is unchanged,
 318       *p_va is undefined,
 319       *levels is a 0-terminated list of item numbers,
 320       *msgbuf contains an error message, whose format is:
 321          "<typename1>, <typename2>", where:
 322             <typename1> is the name of the expected type, and
 323             <typename2> is the name of the actual type,
 324          (so you can surround it by "expected ... found"),
 325       and msgbuf is returned.
 326 */
 327
 328 static char *
 329 converttuple(arg, p_format, p_va, levels, msgbuf, toplevel)
 330         PyObject *arg;
 331         char **p_format;
 332         va_list *p_va;
 333         int *levels;
 334         char *msgbuf;
 335         int toplevel;
 336 {
 337         int level = 0;
 338         int n = 0;
 339         char *format = *p_format;
 340         int i;
 341
 342         for (;;) {
 343                 int c = *format++;
 344                 if (c == '(') {
 345                         if (level == 0)
 346                                 n++;
 347                         level++;
 348                 }
 349                 else if (c == ')') {
 350                         if (level == 0)
 351                                 break;
 352                         level--;
 353                 }
 354                 else if (c == ':' || c == ';' || c == '\0')
 355                         break;
 356                 else if (level == 0 && isalpha(c))
 357                         n++;
 358         }
 359
 360         if (!PySequence_Check(arg)) {
 361                 levels[0] = 0;
 362                 sprintf(msgbuf,
 363                         toplevel ? "%d arguments, %s" : "%d-sequence, %s",
 364                         n, arg == Py_None ? "None" : arg->ob_type->tp_name);
 365                 return msgbuf;
 366         }
 367
 368         if ((i = PySequence_Length(arg)) != n) {
 369                 levels[0] = 0;
 370                 sprintf(msgbuf,
 371                     toplevel ? "%d arguments, %d" : "%d-sequence, %d-sequence",
 372                     n, i);
 373                 return msgbuf;
 374         }
 375
 376         format = *p_format;
 377         for (i = 0; i < n; i++) {
 378                 char *msg;
 379                 PyObject *item;
 380                 item = PySequence_GetItem(arg, i);
 381                 msg = convertitem(item, &format, p_va, levels+1, msgbuf);
 382                 /* PySequence_GetItem calls tp->sq_item, which INCREFs */
 383                 Py_XDECREF(item);
 384                 if (msg != NULL) {
 385                         levels[0] = i+1;
 386                         return msg;
 387                 }
 388         }
 389
 390         *p_format = format;
 391         return NULL;
 392 }
 393
 394
 395 /* Convert a single item. */
 396
 397 static char *
 398 convertitem(arg, p_format, p_va, levels, msgbuf)
 399         PyObject *arg;
 400         char **p_format;
 401         va_list *p_va;
 402         int *levels;
 403         char *msgbuf;
 404 {
 405         char *msg;
 406         char *format = *p_format;
 407
 408         if (*format == '(' /* ')' */) {
 409                 format++;
 410                 msg = converttuple(arg, &format, p_va, levels, msgbuf, 0);
 411                 if (msg == NULL)
 412                         format++;
 413         }
 414         else {
 415                 msg = convertsimple(arg, &format, p_va, msgbuf);
 416                 if (msg != NULL)
 417                         levels[0] = 0;
 418         }
 419         if (msg == NULL)
 420                 *p_format = format;
 421         return msg;
 422 }
 423
 424
 425 /* Convert a non-tuple argument.  Adds to convertsimple1 functionality
 426    by appending ", <actual argument type>" to error message. */
 427
 428 static char *
 429 convertsimple(arg, p_format, p_va, msgbuf)
 430         PyObject *arg;
 431         char **p_format;
 432         va_list *p_va;
 433         char *msgbuf;
 434 {
 435         char *msg = convertsimple1(arg, p_format, p_va);
 436         if (msg != NULL) {
 437                 sprintf(msgbuf, "%.50s, %.50s", msg,
 438                         arg == Py_None ? "None" : arg->ob_type->tp_name);
 439                 msg = msgbuf;
 440         }
 441         return msg;
 442 }
 443
 444
 445 /* Convert a non-tuple argument.  Return NULL if conversion went OK,
 446    or a string representing the expected type if the conversion failed.
 447    When failing, an exception may or may not have been raised.
 448    Don't call if a tuple is expected. */
 449
 450 static char *
 451 convertsimple1(arg, p_format, p_va)
 452         PyObject *arg;
 453         char **p_format;
 454         va_list *p_va;
 455 {
 456         char *format = *p_format;
 457         char c = *format++;
 458
 459         switch (c) {
 460
 461         case 'b': /* byte -- very short int */
 462                 {
 463                         char *p = va_arg(*p_va, char *);
 464                         long ival = PyInt_AsLong(arg);
 465                         if (ival == -1 && PyErr_Occurred())
 466                                 return "integer<b>";
 467                         else
 468                                 *p = (char) ival;
 469                         break;
 470                 }
 471
 472         case 'h': /* short int */
 473                 {
 474                         short *p = va_arg(*p_va, short *);
 475                         long ival = PyInt_AsLong(arg);
 476                         if (ival == -1 && PyErr_Occurred())
 477                                 return "integer<h>";
 478                         else
 479                                 *p = (short) ival;
 480                         break;
 481                 }
 482
 483         case 'i': /* int */
 484                 {
 485                         int *p = va_arg(*p_va, int *);
 486                         long ival = PyInt_AsLong(arg);
 487                         if (ival == -1 && PyErr_Occurred())
 488                                 return "integer<i>";
 489                         else
 490                                 *p = ival;
 491                         break;
 492                 }
 493
 494         case 'l': /* long int */
 495                 {
 496                         long *p = va_arg(*p_va, long *);
 497                         long ival = PyInt_AsLong(arg);
 498                         if (ival == -1 && PyErr_Occurred())
 499                                 return "integer<l>";
 500                         else
 501                                 *p = ival;
 502                         break;
 503                 }
 504
 505 #ifdef HAVE_LONG_LONG
 506         case 'L': /* LONG_LONG */
 507                 {
 508                         LONG_LONG *p = va_arg( *p_va, LONG_LONG * );
 509                         LONG_LONG ival = PyLong_AsLongLong( arg );
 510                         if( ival == (LONG_LONG)-1 && PyErr_Occurred() ) {
 511                                 return "long<L>";
 512                         } else {
 513                                 *p = ival;
 514                         }
 515                         break;
 516                 }
 517 #endif
 518
 519         case 'f': /* float */
 520                 {
 521                         float *p = va_arg(*p_va, float *);
 522                         double dval = PyFloat_AsDouble(arg);
 523                         if (PyErr_Occurred())
 524                                 return "float<f>";
 525                         else
 526                                 *p = (float) dval;
 527                         break;
 528                 }
 529
 530         case 'd': /* double */
 531                 {
 532                         double *p = va_arg(*p_va, double *);
 533                         double dval = PyFloat_AsDouble(arg);
 534                         if (PyErr_Occurred())
 535                                 return "float<d>";
 536                         else
 537                                 *p = dval;
 538                         break;
 539                 }
 540
 541 #ifndef WITHOUT_COMPLEX
 542         case 'D': /* complex double */
 543                 {
 544                         Py_complex *p = va_arg(*p_va, Py_complex *);
 545                         Py_complex cval;
 546                         cval = PyComplex_AsCComplex(arg);
 547                         if (PyErr_Occurred())
 548                                 return "complex<D>";
 549                         else
 550                                 *p = cval;
 551                         break;
 552                 }
 553 #endif /* WITHOUT_COMPLEX */
 554
 555         case 'c': /* char */
 556                 {
 557                         char *p = va_arg(*p_va, char *);
 558                         if (PyString_Check(arg) && PyString_Size(arg) == 1)
 559                                 *p = PyString_AsString(arg)[0];
 560                         else
 561                                 return "char";
 562                         break;
 563                 }
 564
 565         case 's': /* string */
 566                 {
 567                         if (*format == '#') { /* any buffer-like object */
 568                                 void **p = (void **)va_arg(*p_va, char **);
 569                                 PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
 570                                 int *q = va_arg(*p_va, int *);
 571                                 int count;
 572
 573                                 if ( pb == NULL ||
 574                                      pb->bf_getreadbuffer == NULL ||
 575                                      pb->bf_getsegcount == NULL )
 576                                   return "read-only buffer";
 577                                 if ( (*pb->bf_getsegcount)(arg, NULL) != 1 )
 578                                   return "single-segment read-only buffer";
 579                                 if ( (count =
 580                                       (*pb->bf_getreadbuffer)(arg, 0, p)) < 0 )
 581                                   return "(unspecified)";
 582                                 *q = count;
 583                                 format++;
 584                         } else {
 585                                 char **p = va_arg(*p_va, char **);
 586
 587                                 if (PyString_Check(arg))
 588                                   *p = PyString_AsString(arg);
 589                                 else
 590                                   return "string";
 591                                 if ((int)strlen(*p) != PyString_Size(arg))
 592                                   return "string without null bytes";
 593                         }
 594                         break;
 595                 }
 596
 597         case 'z': /* string, may be NULL (None) */
 598                 {
 599                         if (*format == '#') { /* any buffer-like object */
 600                                 void **p = (void **)va_arg(*p_va, char **);
 601                                 PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
 602                                 int *q = va_arg(*p_va, int *);
 603                                 int count;
 604
 605                                 if (arg == Py_None) {
 606                                   *p = 0;
 607                                   *q = 0;
 608                                 } else {
 609                                   if ( pb == NULL ||
 610                                        pb->bf_getreadbuffer == NULL ||
 611                                        pb->bf_getsegcount == NULL )
 612                                     return "read-only buffer";
 613                                   if ( (*pb->bf_getsegcount)(arg, NULL) != 1 )
 614                                   return "single-segment read-only buffer";
 615                                   if ( (count = (*pb->bf_getreadbuffer)
 616                                                             (arg, 0, p)) < 0 )
 617                                     return "(unspecified)";
 618                                   *q = count;
 619                                 }
 620                                 format++;
 621                         } else {
 622                                 char **p = va_arg(*p_va, char **);
 623
 624                                 if (arg == Py_None)
 625                                   *p = 0;
 626                                 else if (PyString_Check(arg))
 627                                   *p = PyString_AsString(arg);
 628                                 else
 629                                   return "None or string";
 630                                 if (*format == '#') {
 631                                   int *q = va_arg(*p_va, int *);
 632                                   if (arg == Py_None)
 633                                     *q = 0;
 634                                   else
 635                                     *q = PyString_Size(arg);
 636                                   format++;
 637                                 }
 638                                 else if (*p != NULL &&
 639                                          (int)strlen(*p) != PyString_Size(arg))
 640                                   return "None or string without null bytes";
 641                         }
 642                         break;
 643                 }
 644
 645         case 'S': /* string object */
 646                 {
 647                         PyObject **p = va_arg(*p_va, PyObject **);
 648                         if (PyString_Check(arg))
 649                                 *p = arg;
 650                         else
 651                                 return "string";
 652                         break;
 653                 }
 654
 655         case 'O': /* object */
 656                 {
 657                         PyTypeObject *type;
 658                         PyObject **p;
 659                         if (*format == '!') {
 660                                 type = va_arg(*p_va, PyTypeObject*);
 661                                 p = va_arg(*p_va, PyObject **);
 662                                 format++;
 663                                 if (arg->ob_type == type)
 664                                         *p = arg;
 665                                 else
 666                                         return type->tp_name;
 667
 668                         }
 669                         else if (*format == '?') {
 670                                 inquiry pred = va_arg(*p_va, inquiry);
 671                                 p = va_arg(*p_va, PyObject **);
 672                                 format++;
 673                                 if ((*pred)(arg))
 674                                         *p = arg;
 675                                 else
 676                                          return "(unspecified)";
 677
 678                         }
 679                         else if (*format == '&') {
 680                                 typedef int (*converter)
 681                                         Py_PROTO((PyObject *, void *));
 682                                 converter convert = va_arg(*p_va, converter);
 683                                 void *addr = va_arg(*p_va, void *);
 684                                 format++;
 685                                 if (! (*convert)(arg, addr))
 686                                         return "(unspecified)";
 687                         }
 688                         else {
 689                                 p = va_arg(*p_va, PyObject **);
 690                                 *p = arg;
 691                         }
 692                         break;
 693                 }
 694
 695
 696         case 'w': /* memory buffer, read-write access */
 697                 {
 698                         void **p = va_arg(*p_va, void **);
 699                         PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
 700                         int count;
 701
 702                         if ( pb == NULL || pb->bf_getwritebuffer == NULL ||
 703                                         pb->bf_getsegcount == NULL )
 704                                 return "read-write buffer";
 705                         if ( (*pb->bf_getsegcount)(arg, NULL) != 1 )
 706                                 return "single-segment read-write buffer";
 707                         if ( (count = pb->bf_getwritebuffer(arg, 0, p)) < 0 )
 708                                 return "(unspecified)";
 709                         if (*format == '#') {
 710                                 int *q = va_arg(*p_va, int *);
 711
 712                                 *q = count;
 713                                 format++;
 714                         }
 715                         break;
 716                 }
 717
 718         case 't': /* 8-bit character buffer, read-only access */
 719                 {
 720                         const char **p = va_arg(*p_va, const char **);
 721                         PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
 722                         int count;
 723
 724                         if ( *format++ != '#' )
 725                                 return "invalid use of 't' format character";
 726                         if ( !PyType_HasFeature(
 727                                 arg->ob_type,
 728                                 Py_TPFLAGS_HAVE_GETCHARBUFFER) ||
 729                              pb == NULL ||
 730                              pb->bf_getcharbuffer == NULL ||
 731                              pb->bf_getsegcount == NULL )
 732                                 return "read-only character buffer";
 733                         if ( (*pb->bf_getsegcount)(arg, NULL) != 1 )
 734                                 return "single-segment read-only buffer";
 735                         if ( (count = pb->bf_getcharbuffer(arg, 0, p)) < 0 )
 736                                 return "(unspecified)";
 737
 738                         *va_arg(*p_va, int *) = count;
 739
 740                         break;
 741                 }
 742
 743
 744         default:
 745                 return "impossible<bad format char>";
 746
 747         }
 748
 749         *p_format = format;
 750         return NULL;
 751 }
 752
 753
 754 /* Support for keyword arguments donated by
 755    Geoff Philbrick <philbric@delphi.hks.com> */
 756
 757 #ifdef HAVE_STDARG_PROTOTYPES
 758 /* VARARGS2 */
 759 int PyArg_ParseTupleAndKeywords(PyObject *args,
 760                                 PyObject *keywords,
 761                                 char *format,
 762                                 char **kwlist, ...)
 763 #else
 764 /* VARARGS */
 765 int PyArg_ParseTupleAndKeywords(va_alist) va_dcl
 766 #endif
 767 {
 768         int retval;
 769         va_list va;
 770 #ifdef HAVE_STDARG_PROTOTYPES
 771
 772         va_start(va, kwlist);
 773 #else
 774         PyObject *args;
 775         PyObject *keywords;
 776         char *format;
 777         char **kwlist;
 778
 779         va_start(va);
 780         args = va_arg(va, PyObject *);
 781         keywords = va_arg(va, PyObject *);
 782         format = va_arg(va, char *);
 783         kwlist = va_arg(va, char **);
 784 #endif
 785         retval = vgetargskeywords(args, keywords, format, kwlist, &va);
 786         va_end(va);
 787         return retval;
 788 }
 789
 790
 791 static int
 792 vgetargskeywords(args, keywords, format, kwlist, p_va)
 793         PyObject *args;
 794         PyObject *keywords;
 795         char *format;
 796         char **kwlist;
 797         va_list *p_va;
 798 {
 799         char msgbuf[256];
 800         int levels[32];
 801         char *fname = NULL;
 802         char *message = NULL;
 803         int min = -1;
 804         int max = 0;
 805         char *formatsave = format;
 806         int i, len, tplen, kwlen;
 807         char *msg, *ks, **p;
 808         int nkwds, pos, match, converted;
 809         PyObject *key, *value;
 810
 811         /* nested tuples cannot be parsed when using keyword arguments */
 812
 813         for (;;) {
 814                 int c = *format++;
 815                 if (c == '(') {
 816                         PyErr_SetString(PyExc_SystemError,
 817                       "tuple found in format when using keyword arguments");
 818                         return 0;
 819                 }
 820                 else if (c == '\0')
 821                         break;
 822                 else if (c == ':') {
 823                         fname = format;
 824                         break;
 825                 }
 826                 else if (c == ';') {
 827                         message = format;
 828                         break;
 829                 }
 830                 else if (isalpha(c))
 831                         max++;
 832                 else if (c == '|')
 833                         min = max;
 834         }
 835
 836         if (min < 0)
 837                 min = max;
 838
 839         format = formatsave;
 840
 841         if (!PyTuple_Check(args)) {
 842                 PyErr_SetString(PyExc_SystemError,
 843                     "new style getargs format but argument is not a tuple");
 844                 return 0;
 845         }
 846
 847         tplen = PyTuple_Size(args);
 848
 849         /* do a cursory check of the keywords just to see how many we got */
 850
 851         if (keywords) {
 852                 if (!PyDict_Check(keywords)) {
 853                         PyErr_SetString(PyExc_SystemError,
 854           "non-dictionary object received when keyword dictionary expected");
 855                         return 0;
 856                 }
 857                 kwlen = PyDict_Size(keywords);
 858         }
 859         else {
 860                 kwlen = 0;
 861         }
 862
 863         /* make sure there are no duplicate values for an argument;
 864            its not clear when to use the term "keyword argument vs.
 865            keyword parameter in messages */
 866
 867         if (keywords) {
 868                 for (i = 0; i < tplen; i++) {
 869                         if (PyMapping_HasKeyString(keywords, kwlist[i])) {
 870                                 sprintf(msgbuf,
 871                                         "keyword parameter %s redefined",
 872                                         kwlist[i]);
 873                                 PyErr_SetString(PyExc_TypeError, msgbuf);
 874                                 return 0;
 875                         }
 876                 }
 877         }
 878         PyErr_Clear(); /* I'm not which Py functions set the error string */
 879
 880         /* required arguments missing from args can be supplied by keyword
 881            arguments */
 882
 883         len = tplen;
 884         if (keywords && tplen < min) {
 885                 for (i = tplen; i < min; i++) {
 886                   if (PyMapping_HasKeyString(keywords, kwlist[i])) {
 887                                 len++;
 888                   }
 889                 }
 890         }
 891         PyErr_Clear();
 892
 893         /* make sure we got an acceptable number of arguments; the message
 894            is a little confusing with keywords since keyword arguments
 895            which are supplied, but don't match the required arguments
 896            are not included in the "%d given" part of the message */
 897
 898         if (len < min || max < len) {
 899                 if (message == NULL) {
 900                         sprintf(msgbuf,
 901                                 "%s requires %s %d argument%s; %d given",
 902                                 fname==NULL ? "function" : fname,
 903                                 min==max ? "exactly"
 904                                          : len < min ? "at least" : "at most",
 905                                 len < min ? min : max,
 906                                 (len < min ? min : max) == 1 ? "" : "s",
 907                                 len);
 908                         message = msgbuf;
 909                 }
 910                 PyErr_SetString(PyExc_TypeError, message);
 911                 return 0;
 912         }
 913
 914         for (i = 0; i < tplen; i++) {
 915                 if (*format == '|')
 916                         format++;
 917                 msg = convertitem(PyTuple_GetItem(args, i), &format, p_va,
 918                                  levels, msgbuf);
 919                 if (msg) {
 920                         seterror(i+1, msg, levels, fname, message);
 921                         return 0;
 922                 }
 923         }
 924
 925         /* handle no keyword parameters in call  */
 926
 927         if (!keywords) return 1;
 928
 929         /* make sure the number of keywords in the keyword list matches the
 930            number of items in the format string */
 931
 932         nkwds = 0;
 933         p =  kwlist;
 934         for (;;) {
 935                 if (!*(p++)) break;
 936                 nkwds++;
 937         }
 938
 939         if (nkwds != max) {
 940                 PyErr_SetString(PyExc_SystemError,
 941           "number of items in format string and keyword list do not match");
 942                 return 0;
 943         }
 944
 945         /* convert the keyword arguments; this uses the format
 946            string where it was left after processing args */
 947
 948         converted = 0;
 949         for (i = tplen; i < nkwds; i++) {
 950                 PyObject *item;
 951                 if (*format == '|')
 952                         format++;
 953                 item = PyMapping_GetItemString(keywords, kwlist[i]);
 954                 if (item != NULL) {
 955                         msg = convertitem(item, &format, p_va, levels, msgbuf);
 956                         if (msg) {
 957                                 seterror(i+1, msg, levels, fname, message);
 958                                 return 0;
 959                         }
 960                         converted++;
 961                 }
 962                 else {
 963                         PyErr_Clear();
 964                         msg = skipitem(&format, p_va);
 965                         if (msg) {
 966                                 seterror(i+1, msg, levels, fname, message);
 967                                 return 0;
 968                         }
 969                 }
 970         }
 971
 972         /* make sure there are no extraneous keyword arguments */
 973
 974         pos = 0;
 975         if (converted < kwlen) {
 976                 while (PyDict_Next(keywords, &pos, &key, &value)) {
 977                         match = 0;
 978                         ks = PyString_AsString(key);
 979                         for (i = 0; i < nkwds; i++) {
 980                                 if (!strcmp(ks, kwlist[i])) {
 981                                         match = 1;
 982                                         break;
 983                                 }
 984                         }
 985                         if (!match) {
 986                                 sprintf(msgbuf,
 987                          "%s is an invalid keyword argument for this function",
 988                                         ks);
 989                                 PyErr_SetString(PyExc_TypeError, msgbuf);
 990                                 return 0;
 991                         }
 992                 }
 993         }
 994
 995         return 1;
 996 }
 997
 998
 999 static char *
1000 skipitem(p_format, p_va)
1001         char **p_format;
1002         va_list *p_va;
1003 {
1004         char *format = *p_format;
1005         char c = *format++;
1006
1007         switch (c) {
1008
1009         case 'b': /* byte -- very short int */
1010                 {
1011                         (void) va_arg(*p_va, char *);
1012                         break;
1013                 }
1014
1015         case 'h': /* short int */
1016                 {
1017                         (void) va_arg(*p_va, short *);
1018                         break;
1019                 }
1020
1021         case 'i': /* int */
1022                 {
1023                         (void) va_arg(*p_va, int *);
1024                         break;
1025                 }
1026
1027         case 'l': /* long int */
1028                 {
1029                         (void) va_arg(*p_va, long *);
1030                         break;
1031                 }
1032
1033 #ifdef HAVE_LONG_LONG
1034         case 'L': /* LONG_LONG int */
1035                 {
1036                         (void) va_arg(*p_va, LONG_LONG *);
1037                         break;
1038                 }
1039 #endif
1040
1041         case 'f': /* float */
1042                 {
1043                         (void) va_arg(*p_va, float *);
1044                         break;
1045                 }
1046
1047         case 'd': /* double */
1048                 {
1049                         (void) va_arg(*p_va, double *);
1050                         break;
1051                 }
1052
1053 #ifndef WITHOUT_COMPLEX
1054         case 'D': /* complex double */
1055                 {
1056                         (void) va_arg(*p_va, Py_complex *);
1057                         break;
1058                 }
1059 #endif /* WITHOUT_COMPLEX */
1060
1061         case 'c': /* char */
1062                 {
1063                         (void) va_arg(*p_va, char *);
1064                         break;
1065                 }
1066
1067         case 's': /* string */
1068                 {
1069                         (void) va_arg(*p_va, char **);
1070                         if (*format == '#') {
1071                                 (void) va_arg(*p_va, int *);
1072                                 format++;
1073                         }
1074                         break;
1075                 }
1076
1077         case 'z': /* string */
1078                 {
1079                         (void) va_arg(*p_va, char **);
1080                         if (*format == '#') {
1081                                 (void) va_arg(*p_va, int *);
1082                                 format++;
1083                         }
1084                         break;
1085                 }
1086
1087         case 'S': /* string object */
1088                 {
1089                         (void) va_arg(*p_va, PyObject **);
1090                         break;
1091                 }
1092
1093         case 'O': /* object */
1094                 {
1095                         if (*format == '!') {
1096                                 format++;
1097                                 (void) va_arg(*p_va, PyTypeObject*);
1098                                 (void) va_arg(*p_va, PyObject **);
1099                         }
1100 #if 0
1101 /* I don't know what this is for */
1102                         else if (*format == '?') {
1103                                 inquiry pred = va_arg(*p_va, inquiry);
1104                                 format++;
1105                                 if ((*pred)(arg)) {
1106                                         (void) va_arg(*p_va, PyObject **);
1107                                 }
1108                         }
1109 #endif
1110                         else if (*format == '&') {
1111                                 typedef int (*converter)
1112                                         Py_PROTO((PyObject *, void *));
1113                                 (void) va_arg(*p_va, converter);
1114                                 (void) va_arg(*p_va, void *);
1115                                 format++;
1116                         }
1117                         else {
1118                                 (void) va_arg(*p_va, PyObject **);
1119                         }
1120                         break;
1121                 }
1122
1123         default:
1124                 return "impossible<bad format char>";
1125
1126         }
1127
1128         *p_format = format;
1129         return NULL;
1130 }