Python/modsupport.c

   1
   2 /* Module support implementation */
   3
   4 #include "Python.h"
   5
   6 #define FLAG_SIZE_T 1
   7 typedef double va_double;
   8
   9 static PyObject *va_build_value(const char *, va_list, int);
  10
  11 /* Package context -- the full module name for package imports */
  12 char *_Py_PackageContext = NULL;
  13
  14 /* Helper for mkvalue() to scan the length of a format */
  15
  16 static int
  17 countformat(const char *format, int endchar)
  18 {
  19         int count = 0;
  20         int level = 0;
  21         while (level > 0 || *format != endchar) {
  22                 switch (*format) {
  23                 case '\0':
  24                         /* Premature end */
  25                         PyErr_SetString(PyExc_SystemError,
  26                                         "unmatched paren in format");
  27                         return -1;
  28                 case '(':
  29                 case '[':
  30                 case '{':
  31                         if (level == 0)
  32                                 count++;
  33                         level++;
  34                         break;
  35                 case ')':
  36                 case ']':
  37                 case '}':
  38                         level--;
  39                         break;
  40                 case '#':
  41                 case '&':
  42                 case ',':
  43                 case ':':
  44                 case ' ':
  45                 case '\t':
  46                         break;
  47                 default:
  48                         if (level == 0)
  49                                 count++;
  50                 }
  51                 format++;
  52         }
  53         return count;
  54 }
  55
  56
  57 /* Generic function to create a value -- the inverse of getargs() */
  58 /* After an original idea and first implementation by Steven Miale */
  59
  60 static PyObject *do_mktuple(const char**, va_list *, int, int, int);
  61 static PyObject *do_mklist(const char**, va_list *, int, int, int);
  62 static PyObject *do_mkdict(const char**, va_list *, int, int, int);
  63 static PyObject *do_mkvalue(const char**, va_list *, int);
  64
  65
  66 static PyObject *
  67 do_mkdict(const char **p_format, va_list *p_va, int endchar, int n, int flags)
  68 {
  69         PyObject *d;
  70         int i;
  71         int itemfailed = 0;
  72         if (n < 0)
  73                 return NULL;
  74         if ((d = PyDict_New()) == NULL)
  75                 return NULL;
  76         /* Note that we can't bail immediately on error as this will leak
  77            refcounts on any 'N' arguments. */
  78         for (i = 0; i < n; i+= 2) {
  79                 PyObject *k, *v;
  80                 int err;
  81                 k = do_mkvalue(p_format, p_va, flags);
  82                 if (k == NULL) {
  83                         itemfailed = 1;
  84                         Py_INCREF(Py_None);
  85                         k = Py_None;
  86                 }
  87                 v = do_mkvalue(p_format, p_va, flags);
  88                 if (v == NULL) {
  89                         itemfailed = 1;
  90                         Py_INCREF(Py_None);
  91                         v = Py_None;
  92                 }
  93                 err = PyDict_SetItem(d, k, v);
  94                 Py_DECREF(k);
  95                 Py_DECREF(v);
  96                 if (err < 0 || itemfailed) {
  97                         Py_DECREF(d);
  98                         return NULL;
  99                 }
 100         }
 101         if (d != NULL && **p_format != endchar) {
 102                 Py_DECREF(d);
 103                 d = NULL;
 104                 PyErr_SetString(PyExc_SystemError,
 105                                 "Unmatched paren in format");
 106         }
 107         else if (endchar)
 108                 ++*p_format;
 109         return d;
 110 }
 111
 112 static PyObject *
 113 do_mklist(const char **p_format, va_list *p_va, int endchar, int n, int flags)
 114 {
 115         PyObject *v;
 116         int i;
 117         int itemfailed = 0;
 118         if (n < 0)
 119                 return NULL;
 120         v = PyList_New(n);
 121         if (v == NULL)
 122                 return NULL;
 123         /* Note that we can't bail immediately on error as this will leak
 124            refcounts on any 'N' arguments. */
 125         for (i = 0; i < n; i++) {
 126                 PyObject *w = do_mkvalue(p_format, p_va, flags);
 127                 if (w == NULL) {
 128                         itemfailed = 1;
 129                         Py_INCREF(Py_None);
 130                         w = Py_None;
 131                 }
 132                 PyList_SET_ITEM(v, i, w);
 133         }
 134
 135         if (itemfailed) {
 136                 /* do_mkvalue() should have already set an error */
 137                 Py_DECREF(v);
 138                 return NULL;
 139         }
 140         if (**p_format != endchar) {
 141                 Py_DECREF(v);
 142                 PyErr_SetString(PyExc_SystemError,
 143                                 "Unmatched paren in format");
 144                 return NULL;
 145         }
 146         if (endchar)
 147                 ++*p_format;
 148         return v;
 149 }
 150
 151 static int
 152 _ustrlen(Py_UNICODE *u)
 153 {
 154         int i = 0;
 155         Py_UNICODE *v = u;
 156         while (*v != 0) { i++; v++; }
 157         return i;
 158 }
 159
 160 static PyObject *
 161 do_mktuple(const char **p_format, va_list *p_va, int endchar, int n, int flags)
 162 {
 163         PyObject *v;
 164         int i;
 165         int itemfailed = 0;
 166         if (n < 0)
 167                 return NULL;
 168         if ((v = PyTuple_New(n)) == NULL)
 169                 return NULL;
 170         /* Note that we can't bail immediately on error as this will leak
 171            refcounts on any 'N' arguments. */
 172         for (i = 0; i < n; i++) {
 173                 PyObject *w = do_mkvalue(p_format, p_va, flags);
 174                 if (w == NULL) {
 175                         itemfailed = 1;
 176                         Py_INCREF(Py_None);
 177                         w = Py_None;
 178                 }
 179                 PyTuple_SET_ITEM(v, i, w);
 180         }
 181         if (itemfailed) {
 182                 /* do_mkvalue() should have already set an error */
 183                 Py_DECREF(v);
 184                 return NULL;
 185         }
 186         if (**p_format != endchar) {
 187                 Py_DECREF(v);
 188                 PyErr_SetString(PyExc_SystemError,
 189                                 "Unmatched paren in format");
 190                 return NULL;
 191         }
 192         if (endchar)
 193                 ++*p_format;
 194         return v;
 195 }
 196
 197 static PyObject *
 198 do_mkvalue(const char **p_format, va_list *p_va, int flags)
 199 {
 200         for (;;) {
 201                 switch (*(*p_format)++) {
 202                 case '(':
 203                         return do_mktuple(p_format, p_va, ')',
 204                                           countformat(*p_format, ')'), flags);
 205
 206                 case '[':
 207                         return do_mklist(p_format, p_va, ']',
 208                                          countformat(*p_format, ']'), flags);
 209
 210                 case '{':
 211                         return do_mkdict(p_format, p_va, '}',
 212                                          countformat(*p_format, '}'), flags);
 213
 214                 case 'b':
 215                 case 'B':
 216                 case 'h':
 217                 case 'i':
 218                         return PyLong_FromLong((long)va_arg(*p_va, int));
 219
 220                 case 'H':
 221                         return PyLong_FromLong((long)va_arg(*p_va, unsigned int));
 222
 223                 case 'I':
 224                 {
 225                         unsigned int n;
 226                         n = va_arg(*p_va, unsigned int);
 227                         return PyLong_FromUnsignedLong(n);
 228                 }
 229
 230                 case 'n':
 231 #if SIZEOF_SIZE_T!=SIZEOF_LONG
 232                         return PyLong_FromSsize_t(va_arg(*p_va, Py_ssize_t));
 233 #endif
 234                         /* Fall through from 'n' to 'l' if Py_ssize_t is long */
 235                 case 'l':
 236                         return PyLong_FromLong(va_arg(*p_va, long));
 237
 238                 case 'k':
 239                 {
 240                         unsigned long n;
 241                         n = va_arg(*p_va, unsigned long);
 242                         return PyLong_FromUnsignedLong(n);
 243                 }
 244
 245 #ifdef HAVE_LONG_LONG
 246                 case 'L':
 247                         return PyLong_FromLongLong((PY_LONG_LONG)va_arg(*p_va, PY_LONG_LONG));
 248
 249                 case 'K':
 250                         return PyLong_FromUnsignedLongLong((PY_LONG_LONG)va_arg(*p_va, unsigned PY_LONG_LONG));
 251 #endif
 252                 case 'u':
 253                 {
 254                         PyObject *v;
 255                         Py_UNICODE *u = va_arg(*p_va, Py_UNICODE *);
 256                         Py_ssize_t n;
 257                         if (**p_format == '#') {
 258                                 ++*p_format;
 259                                 if (flags & FLAG_SIZE_T)
 260                                         n = va_arg(*p_va, Py_ssize_t);
 261                                 else
 262                                         n = va_arg(*p_va, int);
 263                         }
 264                         else
 265                                 n = -1;
 266                         if (u == NULL) {
 267                                 v = Py_None;
 268                                 Py_INCREF(v);
 269                         }
 270                         else {
 271                                 if (n < 0)
 272                                         n = _ustrlen(u);
 273                                 v = PyUnicode_FromUnicode(u, n);
 274                         }
 275                         return v;
 276                 }
 277                 case 'f':
 278                 case 'd':
 279                         return PyFloat_FromDouble(
 280                                 (double)va_arg(*p_va, va_double));
 281
 282 #ifndef WITHOUT_COMPLEX
 283                 case 'D':
 284                         return PyComplex_FromCComplex(
 285                                 *((Py_complex *)va_arg(*p_va, Py_complex *)));
 286 #endif /* WITHOUT_COMPLEX */
 287
 288                 case 'c':
 289                 {
 290                         char p[1];
 291                         p[0] = (char)va_arg(*p_va, int);
 292                         return PyBytes_FromStringAndSize(p, 1);
 293                 }
 294                 case 'C':
 295                 {
 296                         int i = va_arg(*p_va, int);
 297                         if (i < 0 || i > PyUnicode_GetMax()) {
 298                                 PyErr_SetString(PyExc_OverflowError,
 299                                                 "%c arg not in range(0x110000)");
 300                                 return NULL;
 301                         }
 302                         return PyUnicode_FromOrdinal(i);
 303                 }
 304
 305                 case 's':
 306                 case 'z':
 307                 {
 308                         PyObject *v;
 309                         char *str = va_arg(*p_va, char *);
 310                         Py_ssize_t n;
 311                         if (**p_format == '#') {
 312                                 ++*p_format;
 313                                 if (flags & FLAG_SIZE_T)
 314                                         n = va_arg(*p_va, Py_ssize_t);
 315                                 else
 316                                         n = va_arg(*p_va, int);
 317                         }
 318                         else
 319                                 n = -1;
 320                         if (str == NULL) {
 321                                 v = Py_None;
 322                                 Py_INCREF(v);
 323                         }
 324                         else {
 325                                 if (n < 0) {
 326                                         size_t m = strlen(str);
 327                                         if (m > PY_SSIZE_T_MAX) {
 328                                                 PyErr_SetString(PyExc_OverflowError,
 329                                                         "string too long for Python string");
 330                                                 return NULL;
 331                                         }
 332                                         n = (Py_ssize_t)m;
 333                                 }
 334                                 v = PyUnicode_FromStringAndSize(str, n);
 335                         }
 336                         return v;
 337                 }
 338
 339                 case 'U':
 340                 {
 341                         PyObject *v;
 342                         char *str = va_arg(*p_va, char *);
 343                         Py_ssize_t n;
 344                         if (**p_format == '#') {
 345                                 ++*p_format;
 346                                 if (flags & FLAG_SIZE_T)
 347                                         n = va_arg(*p_va, Py_ssize_t);
 348                                 else
 349                                         n = va_arg(*p_va, int);
 350                         }
 351                         else
 352                                 n = -1;
 353                         if (str == NULL) {
 354                                 v = Py_None;
 355                                 Py_INCREF(v);
 356                         }
 357                         else {
 358                                 if (n < 0) {
 359                                         size_t m = strlen(str);
 360                                         if (m > PY_SSIZE_T_MAX) {
 361                                                 PyErr_SetString(PyExc_OverflowError,
 362                                                         "string too long for Python string");
 363                                                 return NULL;
 364                                         }
 365                                         n = (Py_ssize_t)m;
 366                                 }
 367                                 v = PyUnicode_FromStringAndSize(str, n);
 368                         }
 369                         return v;
 370                 }
 371
 372                 case 'y':
 373                 {
 374                         PyObject *v;
 375                         char *str = va_arg(*p_va, char *);
 376                         Py_ssize_t n;
 377                         if (**p_format == '#') {
 378                                 ++*p_format;
 379                                 if (flags & FLAG_SIZE_T)
 380                                         n = va_arg(*p_va, Py_ssize_t);
 381                                 else
 382                                         n = va_arg(*p_va, int);
 383                         }
 384                         else
 385                                 n = -1;
 386                         if (str == NULL) {
 387                                 v = Py_None;
 388                                 Py_INCREF(v);
 389                         }
 390                         else {
 391                                 if (n < 0) {
 392                                         size_t m = strlen(str);
 393                                         if (m > PY_SSIZE_T_MAX) {
 394                                                 PyErr_SetString(PyExc_OverflowError,
 395                                                         "string too long for Python bytes");
 396                                                 return NULL;
 397                                         }
 398                                         n = (Py_ssize_t)m;
 399                                 }
 400                                 v = PyBytes_FromStringAndSize(str, n);
 401                         }
 402                         return v;
 403                 }
 404
 405                 case 'N':
 406                 case 'S':
 407                 case 'O':
 408                 if (**p_format == '&') {
 409                         typedef PyObject *(*converter)(void *);
 410                         converter func = va_arg(*p_va, converter);
 411                         void *arg = va_arg(*p_va, void *);
 412                         ++*p_format;
 413                         return (*func)(arg);
 414                 }
 415                 else {
 416                         PyObject *v;
 417                         v = va_arg(*p_va, PyObject *);
 418                         if (v != NULL) {
 419                                 if (*(*p_format - 1) != 'N')
 420                                         Py_INCREF(v);
 421                         }
 422                         else if (!PyErr_Occurred())
 423                                 /* If a NULL was passed
 424                                  * because a call that should
 425                                  * have constructed a value
 426                                  * failed, that's OK, and we
 427                                  * pass the error on; but if
 428                                  * no error occurred it's not
 429                                  * clear that the caller knew
 430                                  * what she was doing. */
 431                                 PyErr_SetString(PyExc_SystemError,
 432                                         "NULL object passed to Py_BuildValue");
 433                         return v;
 434                 }
 435
 436                 case ':':
 437                 case ',':
 438                 case ' ':
 439                 case '\t':
 440                         break;
 441
 442                 default:
 443                         PyErr_SetString(PyExc_SystemError,
 444                                 "bad format char passed to Py_BuildValue");
 445                         return NULL;
 446
 447                 }
 448         }
 449 }
 450
 451
 452 PyObject *
 453 Py_BuildValue(const char *format, ...)
 454 {
 455         va_list va;
 456         PyObject* retval;
 457         va_start(va, format);
 458         retval = va_build_value(format, va, 0);
 459         va_end(va);
 460         return retval;
 461 }
 462
 463 PyObject *
 464 _Py_BuildValue_SizeT(const char *format, ...)
 465 {
 466         va_list va;
 467         PyObject* retval;
 468         va_start(va, format);
 469         retval = va_build_value(format, va, FLAG_SIZE_T);
 470         va_end(va);
 471         return retval;
 472 }
 473
 474 PyObject *
 475 Py_VaBuildValue(const char *format, va_list va)
 476 {
 477         return va_build_value(format, va, 0);
 478 }
 479
 480 PyObject *
 481 _Py_VaBuildValue_SizeT(const char *format, va_list va)
 482 {
 483         return va_build_value(format, va, FLAG_SIZE_T);
 484 }
 485
 486 static PyObject *
 487 va_build_value(const char *format, va_list va, int flags)
 488 {
 489         const char *f = format;
 490         int n = countformat(f, '\0');
 491         va_list lva;
 492
 493 #ifdef VA_LIST_IS_ARRAY
 494         memcpy(lva, va, sizeof(va_list));
 495 #else
 496 #ifdef __va_copy
 497         __va_copy(lva, va);
 498 #else
 499         lva = va;
 500 #endif
 501 #endif
 502
 503         if (n < 0)
 504                 return NULL;
 505         if (n == 0) {
 506                 Py_INCREF(Py_None);
 507                 return Py_None;
 508         }
 509         if (n == 1)
 510                 return do_mkvalue(&f, &lva, flags);
 511         return do_mktuple(&f, &lva, '\0', n, flags);
 512 }
 513
 514
 515 PyObject *
 516 PyEval_CallFunction(PyObject *obj, const char *format, ...)
 517 {
 518         va_list vargs;
 519         PyObject *args;
 520         PyObject *res;
 521
 522         va_start(vargs, format);
 523
 524         args = Py_VaBuildValue(format, vargs);
 525         va_end(vargs);
 526
 527         if (args == NULL)
 528                 return NULL;
 529
 530         res = PyEval_CallObject(obj, args);
 531         Py_DECREF(args);
 532
 533         return res;
 534 }
 535
 536
 537 PyObject *
 538 PyEval_CallMethod(PyObject *obj, const char *methodname, const char *format, ...)
 539 {
 540         va_list vargs;
 541         PyObject *meth;
 542         PyObject *args;
 543         PyObject *res;
 544
 545         meth = PyObject_GetAttrString(obj, methodname);
 546         if (meth == NULL)
 547                 return NULL;
 548
 549         va_start(vargs, format);
 550
 551         args = Py_VaBuildValue(format, vargs);
 552         va_end(vargs);
 553
 554         if (args == NULL) {
 555                 Py_DECREF(meth);
 556                 return NULL;
 557         }
 558
 559         res = PyEval_CallObject(meth, args);
 560         Py_DECREF(meth);
 561         Py_DECREF(args);
 562
 563         return res;
 564 }
 565
 566 int
 567 PyModule_AddObject(PyObject *m, const char *name, PyObject *o)
 568 {
 569         PyObject *dict;
 570         if (!PyModule_Check(m)) {
 571                 PyErr_SetString(PyExc_TypeError,
 572                             "PyModule_AddObject() needs module as first arg");
 573                 return -1;
 574         }
 575         if (!o) {
 576                 if (!PyErr_Occurred())
 577                         PyErr_SetString(PyExc_TypeError,
 578                                         "PyModule_AddObject() needs non-NULL value");
 579                 return -1;
 580         }
 581
 582         dict = PyModule_GetDict(m);
 583         if (dict == NULL) {
 584                 /* Internal error -- modules must have a dict! */
 585                 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
 586                              PyModule_GetName(m));
 587                 return -1;
 588         }
 589         if (PyDict_SetItemString(dict, name, o))
 590                 return -1;
 591         Py_DECREF(o);
 592         return 0;
 593 }
 594
 595 int
 596 PyModule_AddIntConstant(PyObject *m, const char *name, long value)
 597 {
 598         PyObject *o = PyLong_FromLong(value);
 599         if (!o)
 600                 return -1;
 601         if (PyModule_AddObject(m, name, o) == 0)
 602                 return 0;
 603         Py_DECREF(o);
 604         return -1;
 605 }
 606
 607 int
 608 PyModule_AddStringConstant(PyObject *m, const char *name, const char *value)
 609 {
 610         PyObject *o = PyUnicode_FromString(value);
 611         if (!o)
 612                 return -1;
 613         if (PyModule_AddObject(m, name, o) == 0)
 614                 return 0;
 615         Py_DECREF(o);
 616         return -1;
 617 }