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