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