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                         if (PyUnicode_Check(arg)) {
 842                                 *p = PyUnicode_AS_UNICODE(arg);
 843                                 *q = PyUnicode_GET_SIZE(arg);
 844                         }
 845                         else {
 846                         char *buf;
 847                         int count = convertbuffer(arg, p, &buf);
 848                         if (count < 0)
 849                                 return converterr(buf, arg, msgbuf, bufsize);
 850                         *q = count/(sizeof(Py_UNICODE));
 851                         }
 852                         format++;
 853                 } else {
 854                         Py_UNICODE **p = va_arg(*p_va, Py_UNICODE **);
 855                         if (PyUnicode_Check(arg))
 856                                 *p = PyUnicode_AS_UNICODE(arg);
 857                         else
 858                                 return converterr("unicode", arg, msgbuf, bufsize);
 859                 }
 860                 break;
 861         }
 862 #endif
 863
 864         case 'S': { /* string object */
 865                 PyObject **p = va_arg(*p_va, PyObject **);
 866                 if (PyString_Check(arg))
 867                         *p = arg;
 868                 else
 869                         return converterr("string", arg, msgbuf, bufsize);
 870                 break;
 871         }
 872
 873 #ifdef Py_USING_UNICODE
 874         case 'U': { /* Unicode object */
 875                 PyObject **p = va_arg(*p_va, PyObject **);
 876                 if (PyUnicode_Check(arg))
 877                         *p = arg;
 878                 else
 879                         return converterr("unicode", arg, msgbuf, bufsize);
 880                 break;
 881         }
 882 #endif
 883
 884         case 'O': { /* object */
 885                 PyTypeObject *type;
 886                 PyObject **p;
 887                 if (*format == '!') {
 888                         type = va_arg(*p_va, PyTypeObject*);
 889                         p = va_arg(*p_va, PyObject **);
 890                         format++;
 891                         if (PyType_IsSubtype(arg->ob_type, type))
 892                                 *p = arg;
 893                         else
 894                                 return converterr(type->tp_name, arg, msgbuf, bufsize);
 895
 896                 }
 897                 else if (*format == '?') {
 898                         inquiry pred = va_arg(*p_va, inquiry);
 899                         p = va_arg(*p_va, PyObject **);
 900                         format++;
 901                         if ((*pred)(arg))
 902                                 *p = arg;
 903                         else
 904                                 return converterr("(unspecified)",
 905                                                   arg, msgbuf, bufsize);
 906
 907                 }
 908                 else if (*format == '&') {
 909                         typedef int (*converter)(PyObject *, void *);
 910                         converter convert = va_arg(*p_va, converter);
 911                         void *addr = va_arg(*p_va, void *);
 912                         format++;
 913                         if (! (*convert)(arg, addr))
 914                                 return converterr("(unspecified)",
 915                                                   arg, msgbuf, bufsize);
 916                 }
 917                 else {
 918                         p = va_arg(*p_va, PyObject **);
 919                         *p = arg;
 920                 }
 921                 break;
 922         }
 923
 924
 925         case 'w': { /* memory buffer, read-write access */
 926                 void **p = va_arg(*p_va, void **);
 927                 PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
 928                 int count;
 929
 930                 if (pb == NULL ||
 931                     pb->bf_getwritebuffer == NULL ||
 932                     pb->bf_getsegcount == NULL)
 933                         return converterr("read-write buffer", arg, msgbuf, bufsize);
 934                 if ((*pb->bf_getsegcount)(arg, NULL) != 1)
 935                         return converterr("single-segment read-write buffer",
 936                                           arg, msgbuf, bufsize);
 937                 if ((count = pb->bf_getwritebuffer(arg, 0, p)) < 0)
 938                         return converterr("(unspecified)", arg, msgbuf, bufsize);
 939                 if (*format == '#') {
 940                         int *q = va_arg(*p_va, int *);
 941
 942                         *q = count;
 943                         format++;
 944                 }
 945                 break;
 946         }
 947
 948         case 't': { /* 8-bit character buffer, read-only access */
 949                 const char **p = va_arg(*p_va, const char **);
 950                 PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
 951                 int count;
 952
 953                 if (*format++ != '#')
 954                         return converterr(
 955                                 "invalid use of 't' format character",
 956                                 arg, msgbuf, bufsize);
 957                 if (!PyType_HasFeature(arg->ob_type,
 958                                        Py_TPFLAGS_HAVE_GETCHARBUFFER) ||
 959                     pb == NULL || pb->bf_getcharbuffer == NULL ||
 960                     pb->bf_getsegcount == NULL)
 961                         return converterr(
 962                                 "string or read-only character buffer",
 963                                 arg, msgbuf, bufsize);
 964
 965                 if (pb->bf_getsegcount(arg, NULL) != 1)
 966                         return converterr(
 967                                 "string or single-segment read-only buffer",
 968                                 arg, msgbuf, bufsize);
 969
 970                 count = pb->bf_getcharbuffer(arg, 0, p);
 971                 if (count < 0)
 972                         return converterr("(unspecified)", arg, msgbuf, bufsize);
 973                 *va_arg(*p_va, int *) = count;
 974                 break;
 975         }
 976
 977         default:
 978                 return converterr("impossible<bad format char>", arg, msgbuf, bufsize);
 979
 980         }
 981
 982         *p_format = format;
 983         return NULL;
 984 }
 985
 986 static int
 987 convertbuffer(PyObject *arg, void **p, char **errmsg)
 988 {
 989         PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
 990         int count;
 991         if (pb == NULL ||
 992             pb->bf_getreadbuffer == NULL ||
 993             pb->bf_getsegcount == NULL) {
 994                 *errmsg = "string or read-only buffer";
 995                 return -1;
 996         }
 997         if ((*pb->bf_getsegcount)(arg, NULL) != 1) {
 998                 *errmsg = "string or single-segment read-only buffer";
 999                 return -1;
1000         }
1001         if ((count = (*pb->bf_getreadbuffer)(arg, 0, p)) < 0) {
1002                 *errmsg = "(unspecified)";
1003         }
1004         return count;
1005 }
1006
1007 /* Support for keyword arguments donated by
1008    Geoff Philbrick <philbric@delphi.hks.com> */
1009
1010 /* Return false (0) for error, else true. */
1011 int
1012 PyArg_ParseTupleAndKeywords(PyObject *args,
1013                             PyObject *keywords,
1014                             char *format,
1015                             char **kwlist, ...)
1016 {
1017         int retval;
1018         va_list va;
1019
1020         if ((args == NULL || !PyTuple_Check(args)) ||
1021             (keywords != NULL && !PyDict_Check(keywords)) ||
1022             format == NULL ||
1023             kwlist == NULL)
1024         {
1025                 PyErr_BadInternalCall();
1026                 return 0;
1027         }
1028
1029         va_start(va, kwlist);
1030         retval = vgetargskeywords(args, keywords, format, kwlist, &va);
1031         va_end(va);
1032         return retval;
1033 }
1034
1035
1036 static int
1037 vgetargskeywords(PyObject *args, PyObject *keywords, char *format,
1038                  char **kwlist, va_list *p_va)
1039 {
1040         char msgbuf[512];
1041         int levels[32];
1042         char *fname, *message;
1043         int min, max;
1044         char *formatsave;
1045         int i, len, nargs, nkeywords;
1046         char *msg, **p;
1047
1048         assert(args != NULL && PyTuple_Check(args));
1049         assert(keywords == NULL || PyDict_Check(keywords));
1050         assert(format != NULL);
1051         assert(kwlist != NULL);
1052         assert(p_va != NULL);
1053
1054         /* Search the format:
1055            message <- error msg, if any (else NULL).
1056            fname <- routine name, if any (else NULL).
1057            min <- # of required arguments, or -1 if all are required.
1058            max <- most arguments (required + optional).
1059            Check that kwlist has a non-NULL entry for each arg.
1060            Raise error if a tuple arg spec is found.
1061         */
1062         fname = message = NULL;
1063         formatsave = format;
1064         p = kwlist;
1065         min = -1;
1066         max = 0;
1067         while ((i = *format++) != '\0') {
1068                 if (isalpha(i) && i != 'e') {
1069                         max++;
1070                         if (*p == NULL) {
1071                                 PyErr_SetString(PyExc_RuntimeError,
1072                                         "more argument specifiers than "
1073                                         "keyword list entries");
1074                                 return 0;
1075                         }
1076                         p++;
1077                 }
1078                 else if (i == '|')
1079                         min = max;
1080                 else if (i == ':') {
1081                         fname = format;
1082                         break;
1083                 }
1084                 else if (i == ';') {
1085                         message = format;
1086                         break;
1087                 }
1088                 else if (i == '(') {
1089                         PyErr_SetString(PyExc_RuntimeError,
1090                                 "tuple found in format when using keyword "
1091                                 "arguments");
1092                         return 0;
1093                 }
1094         }
1095         format = formatsave;
1096         if (*p != NULL) {
1097                 PyErr_SetString(PyExc_RuntimeError,
1098                         "more keyword list entries than "
1099                         "argument specifiers");
1100                 return 0;
1101         }
1102         if (min < 0) {
1103                 /* All arguments are required. */
1104                 min = max;
1105         }
1106
1107         nargs = PyTuple_GET_SIZE(args);
1108         nkeywords = keywords == NULL ? 0 : PyDict_Size(keywords);
1109
1110         /* make sure there are no duplicate values for an argument;
1111            its not clear when to use the term "keyword argument vs.
1112            keyword parameter in messages */
1113         if (nkeywords > 0) {
1114                 for (i = 0; i < nargs; i++) {
1115                         char *thiskw = kwlist[i];
1116                         if (thiskw == NULL)
1117                                 break;
1118                         if (PyDict_GetItemString(keywords, thiskw)) {
1119                                 PyErr_Format(PyExc_TypeError,
1120                                         "keyword parameter '%s' was given "
1121                                         "by position and by name",
1122                                         thiskw);
1123                                 return 0;
1124                         }
1125                         else if (PyErr_Occurred())
1126                                 return 0;
1127                 }
1128         }
1129
1130         /* required arguments missing from args can be supplied by keyword
1131            arguments; set len to the number of posiitional arguments, and,
1132            if that's less than the minimum required, add in the number of
1133            required arguments that are supplied by keywords */
1134         len = nargs;
1135         if (nkeywords > 0 && nargs < min) {
1136                 for (i = nargs; i < min; i++) {
1137                         if (PyDict_GetItemString(keywords, kwlist[i]))
1138                                 len++;
1139                         else if (PyErr_Occurred())
1140                                 return 0;
1141                 }
1142         }
1143
1144         /* make sure we got an acceptable number of arguments; the message
1145            is a little confusing with keywords since keyword arguments
1146            which are supplied, but don't match the required arguments
1147            are not included in the "%d given" part of the message */
1148         if (len < min || max < len) {
1149                 if (message == NULL) {
1150                         PyOS_snprintf(msgbuf, sizeof(msgbuf),
1151                                       "%.200s%s takes %s %d argument%s "
1152                                       "(%d given)",
1153                                       fname==NULL ? "function" : fname,
1154                                       fname==NULL ? "" : "()",
1155                                       min==max ? "exactly"
1156                                       : len < min ? "at least" : "at most",
1157                                       len < min ? min : max,
1158                                       (len < min ? min : max) == 1 ? "" : "s",
1159                                       len);
1160                         message = msgbuf;
1161                 }
1162                 PyErr_SetString(PyExc_TypeError, message);
1163                 return 0;
1164         }
1165
1166         /* convert the positional arguments */
1167         for (i = 0; i < nargs; i++) {
1168                 if (*format == '|')
1169                         format++;
1170                 msg = convertitem(PyTuple_GET_ITEM(args, i), &format, p_va,
1171                                  levels, msgbuf, sizeof(msgbuf));
1172                 if (msg) {
1173                         seterror(i+1, msg, levels, fname, message);
1174                         return 0;
1175                 }
1176         }
1177
1178         /* handle no keyword parameters in call */
1179         if (nkeywords == 0)
1180                 return 1;
1181
1182         /* convert the keyword arguments; this uses the format
1183            string where it was left after processing args */
1184         for (i = nargs; i < max; i++) {
1185                 PyObject *item;
1186                 if (*format == '|')
1187                         format++;
1188                 item = PyDict_GetItemString(keywords, kwlist[i]);
1189                 if (item != NULL) {
1190                         Py_INCREF(item);
1191                         msg = convertitem(item, &format, p_va, levels, msgbuf,
1192                                           sizeof(msgbuf));
1193                         Py_DECREF(item);
1194                         if (msg) {
1195                                 seterror(i+1, msg, levels, fname, message);
1196                                 return 0;
1197                         }
1198                         --nkeywords;
1199                         if (nkeywords == 0)
1200                                 break;
1201                 }
1202                 else if (PyErr_Occurred())
1203                         return 0;
1204                 else {
1205                         msg = skipitem(&format, p_va);
1206                         if (msg) {
1207                                 seterror(i+1, msg, levels, fname, message);
1208                                 return 0;
1209                         }
1210                 }
1211         }
1212
1213         /* make sure there are no extraneous keyword arguments */
1214         if (nkeywords > 0) {
1215                 PyObject *key, *value;
1216                 int pos = 0;
1217                 while (PyDict_Next(keywords, &pos, &key, &value)) {
1218                         int match = 0;
1219                         char *ks;
1220                         if (!PyString_Check(key)) {
1221                                 PyErr_SetString(PyExc_TypeError,
1222                                                 "keywords must be strings");
1223                                 return 0;
1224                         }
1225                         ks = PyString_AsString(key);
1226                         for (i = 0; i < max; i++) {
1227                                 if (!strcmp(ks, kwlist[i])) {
1228                                         match = 1;
1229                                         break;
1230                                 }
1231                         }
1232                         if (!match) {
1233                                 PyErr_Format(PyExc_TypeError,
1234                                              "'%s' is an invalid keyword "
1235                                              "argument for this function",
1236                                              ks);
1237                                 return 0;
1238                         }
1239                 }
1240         }
1241
1242         return 1;
1243 }
1244
1245
1246 static char *
1247 skipitem(char **p_format, va_list *p_va)
1248 {
1249         char *format = *p_format;
1250         char c = *format++;
1251
1252         switch (c) {
1253
1254         case 'b': /* byte -- very short int */
1255         case 'B': /* byte as bitfield */
1256                 {
1257                         (void) va_arg(*p_va, char *);
1258                         break;
1259                 }
1260
1261         case 'h': /* short int */
1262                 {
1263                         (void) va_arg(*p_va, short *);
1264                         break;
1265                 }
1266
1267         case 'H': /* short int as bitfield */
1268                 {
1269                         (void) va_arg(*p_va, unsigned short *);
1270                         break;
1271                 }
1272
1273         case 'i': /* int */
1274                 {
1275                         (void) va_arg(*p_va, int *);
1276                         break;
1277                 }
1278
1279         case 'l': /* long int */
1280                 {
1281                         (void) va_arg(*p_va, long *);
1282                         break;
1283                 }
1284
1285 #ifdef HAVE_LONG_LONG
1286         case 'L': /* LONG_LONG int */
1287                 {
1288                         (void) va_arg(*p_va, LONG_LONG *);
1289                         break;
1290                 }
1291 #endif
1292
1293         case 'f': /* float */
1294                 {
1295                         (void) va_arg(*p_va, float *);
1296                         break;
1297                 }
1298
1299         case 'd': /* double */
1300                 {
1301                         (void) va_arg(*p_va, double *);
1302                         break;
1303                 }
1304
1305 #ifndef WITHOUT_COMPLEX
1306         case 'D': /* complex double */
1307                 {
1308                         (void) va_arg(*p_va, Py_complex *);
1309                         break;
1310                 }
1311 #endif /* WITHOUT_COMPLEX */
1312
1313         case 'c': /* char */
1314                 {
1315                         (void) va_arg(*p_va, char *);
1316                         break;
1317                 }
1318
1319         case 's': /* 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 'z': /* string */
1330                 {
1331                         (void) va_arg(*p_va, char **);
1332                         if (*format == '#') {
1333                                 (void) va_arg(*p_va, int *);
1334                                 format++;
1335                         }
1336                         break;
1337                 }
1338
1339         case 'S': /* string object */
1340                 {
1341                         (void) va_arg(*p_va, PyObject **);
1342                         break;
1343                 }
1344
1345         case 'O': /* object */
1346                 {
1347                         if (*format == '!') {
1348                                 format++;
1349                                 (void) va_arg(*p_va, PyTypeObject*);
1350                                 (void) va_arg(*p_va, PyObject **);
1351                         }
1352 #if 0
1353 /* I don't know what this is for */
1354                         else if (*format == '?') {
1355                                 inquiry pred = va_arg(*p_va, inquiry);
1356                                 format++;
1357                                 if ((*pred)(arg)) {
1358                                         (void) va_arg(*p_va, PyObject **);
1359                                 }
1360                         }
1361 #endif
1362                         else if (*format == '&') {
1363                                 typedef int (*converter)(PyObject *, void *);
1364                                 (void) va_arg(*p_va, converter);
1365                                 (void) va_arg(*p_va, void *);
1366                                 format++;
1367                         }
1368                         else {
1369                                 (void) va_arg(*p_va, PyObject **);
1370                         }
1371                         break;
1372                 }
1373
1374         default:
1375                 return "impossible<bad format char>";
1376
1377         }
1378
1379         *p_format = format;
1380         return NULL;
1381 }
1382
1383
1384 int
1385 PyArg_UnpackTuple(PyObject *args, char *name, int min, int max, ...)
1386 {
1387         int i, l;
1388         PyObject **o;
1389         va_list vargs;
1390
1391 #ifdef HAVE_STDARG_PROTOTYPES
1392         va_start(vargs, max);
1393 #else
1394         va_start(vargs);
1395 #endif
1396
1397         assert(min >= 0);
1398         assert(min <= max);
1399         if (!PyTuple_Check(args)) {
1400                 PyErr_SetString(PyExc_SystemError,
1401                     "PyArg_UnpackTuple() argument list is not a tuple");
1402                 return 0;
1403         }
1404         l = PyTuple_GET_SIZE(args);
1405         if (l < min) {
1406                 if (name != NULL)
1407                         PyErr_Format(
1408                             PyExc_TypeError,
1409                             "%s expected %s%d arguments, got %d",
1410                             name, (min == max ? "" : "at least "), min, l);
1411                 else
1412                         PyErr_Format(
1413                             PyExc_TypeError,
1414                             "unpacked tuple should have %s%d elements,"
1415                             " but has %d",
1416                             (min == max ? "" : "at least "), min, l);
1417                 va_end(vargs);
1418                 return 0;
1419         }
1420         if (l > max) {
1421                 if (name != NULL)
1422                         PyErr_Format(
1423                             PyExc_TypeError,
1424                             "%s expected %s%d arguments, got %d",
1425                             name, (min == max ? "" : "at most "), max, l);
1426                 else
1427                         PyErr_Format(
1428                             PyExc_TypeError,
1429                             "unpacked tuple should have %s%d elements,"
1430                             " but has %d",
1431                             (min == max ? "" : "at most "), max, l);
1432                 va_end(vargs);
1433                 return 0;
1434         }
1435         for (i = 0; i < l; i++) {
1436                 o = va_arg(vargs, PyObject **);
1437                 *o = PyTuple_GET_ITEM(args, i);
1438         }
1439         va_end(vargs);
1440         return 1;
1441 }