1#include "Python.h" 2#include "frameobject.h" 3 4#define MODULE_NAME "_warnings" 5 6PyDoc_STRVAR(warnings__doc__, 7MODULE_NAME " provides basic warning filtering support.\n" 8"It is a helper module to speed up interpreter start-up."); 9 10/* Both 'filters' and 'onceregistry' can be set in warnings.py; 11 get_warnings_attr() will reset these variables accordingly. */ 12static PyObject *_filters; /* List */ 13static PyObject *_once_registry; /* Dict */ 14static PyObject *_default_action; /* String */ 15 16 17static int 18check_matched(PyObject *obj, PyObject *arg) 19{ 20 PyObject *result; 21 int rc; 22 23 if (obj == Py_None) 24 return 1; 25 result = PyObject_CallMethod(obj, "match", "O", arg); 26 if (result == NULL) 27 return -1; 28 29 rc = PyObject_IsTrue(result); 30 Py_DECREF(result); 31 return rc; 32} 33 34/* 35 Returns a new reference. 36 A NULL return value can mean false or an error. 37*/ 38static PyObject * 39get_warnings_attr(const char *attr) 40{ 41 static PyObject *warnings_str = NULL; 42 PyObject *all_modules; 43 PyObject *warnings_module; 44 int result; 45 46 if (warnings_str == NULL) { 47 warnings_str = PyString_InternFromString("warnings"); 48 if (warnings_str == NULL) 49 return NULL; 50 } 51 52 all_modules = PyImport_GetModuleDict(); 53 result = PyDict_Contains(all_modules, warnings_str); 54 if (result == -1 || result == 0) 55 return NULL; 56 57 warnings_module = PyDict_GetItem(all_modules, warnings_str); 58 if (!PyObject_HasAttrString(warnings_module, attr)) 59 return NULL; 60 return PyObject_GetAttrString(warnings_module, attr); 61} 62 63 64static PyObject * 65get_once_registry(void) 66{ 67 PyObject *registry; 68 69 registry = get_warnings_attr("onceregistry"); 70 if (registry == NULL) { 71 if (PyErr_Occurred()) 72 return NULL; 73 return _once_registry; 74 } 75 Py_DECREF(_once_registry); 76 _once_registry = registry; 77 return registry; 78} 79 80 81static PyObject * 82get_default_action(void) 83{ 84 PyObject *default_action; 85 86 default_action = get_warnings_attr("defaultaction"); 87 if (default_action == NULL) { 88 if (PyErr_Occurred()) { 89 return NULL; 90 } 91 return _default_action; 92 } 93 94 Py_DECREF(_default_action); 95 _default_action = default_action; 96 return default_action; 97} 98 99 100/* The item is a borrowed reference. */ 101static const char * 102get_filter(PyObject *category, PyObject *text, Py_ssize_t lineno, 103 PyObject *module, PyObject **item) 104{ 105 PyObject *action; 106 Py_ssize_t i; 107 PyObject *warnings_filters; 108 109 warnings_filters = get_warnings_attr("filters"); 110 if (warnings_filters == NULL) { 111 if (PyErr_Occurred()) 112 return NULL; 113 } 114 else { 115 Py_DECREF(_filters); 116 _filters = warnings_filters; 117 } 118 119 if (!PyList_Check(_filters)) { 120 PyErr_SetString(PyExc_ValueError, 121 MODULE_NAME ".filters must be a list"); 122 return NULL; 123 } 124 125 /* _filters could change while we are iterating over it. */ 126 for (i = 0; i < PyList_GET_SIZE(_filters); i++) { 127 PyObject *tmp_item, *action, *msg, *cat, *mod, *ln_obj; 128 Py_ssize_t ln; 129 int is_subclass, good_msg, good_mod; 130 131 tmp_item = *item = PyList_GET_ITEM(_filters, i); 132 if (PyTuple_Size(tmp_item) != 5) { 133 PyErr_Format(PyExc_ValueError, 134 MODULE_NAME ".filters item %zd isn't a 5-tuple", i); 135 return NULL; 136 } 137 138 /* Python code: action, msg, cat, mod, ln = item */ 139 action = PyTuple_GET_ITEM(tmp_item, 0); 140 msg = PyTuple_GET_ITEM(tmp_item, 1); 141 cat = PyTuple_GET_ITEM(tmp_item, 2); 142 mod = PyTuple_GET_ITEM(tmp_item, 3); 143 ln_obj = PyTuple_GET_ITEM(tmp_item, 4); 144 145 good_msg = check_matched(msg, text); 146 good_mod = check_matched(mod, module); 147 is_subclass = PyObject_IsSubclass(category, cat); 148 ln = PyInt_AsSsize_t(ln_obj); 149 if (good_msg == -1 || good_mod == -1 || is_subclass == -1 || 150 (ln == -1 && PyErr_Occurred())) 151 return NULL; 152 153 if (good_msg && is_subclass && good_mod && (ln == 0 || lineno == ln)) 154 return PyString_AsString(action); 155 } 156 157 action = get_default_action(); 158 if (action != NULL) { 159 return PyString_AsString(action); 160 } 161 162 PyErr_SetString(PyExc_ValueError, 163 MODULE_NAME ".defaultaction not found"); 164 return NULL; 165} 166 167 168static int 169already_warned(PyObject *registry, PyObject *key, int should_set) 170{ 171 PyObject *already_warned; 172 173 if (key == NULL) 174 return -1; 175 176 already_warned = PyDict_GetItem(registry, key); 177 if (already_warned != NULL) { 178 int rc = PyObject_IsTrue(already_warned); 179 if (rc != 0) 180 return rc; 181 } 182 183 /* This warning wasn't found in the registry, set it. */ 184 if (should_set) 185 return PyDict_SetItem(registry, key, Py_True); 186 return 0; 187} 188 189/* New reference. */ 190static PyObject * 191normalize_module(PyObject *filename) 192{ 193 PyObject *module; 194 const char *mod_str; 195 Py_ssize_t len; 196 197 int rc = PyObject_IsTrue(filename); 198 if (rc == -1) 199 return NULL; 200 else if (rc == 0) 201 return PyString_FromString("<unknown>"); 202 203 mod_str = PyString_AsString(filename); 204 if (mod_str == NULL) 205 return NULL; 206 len = PyString_Size(filename); 207 if (len < 0) 208 return NULL; 209 if (len >= 3 && 210 strncmp(mod_str + (len - 3), ".py", 3) == 0) { 211 module = PyString_FromStringAndSize(mod_str, len-3); 212 } 213 else { 214 module = filename; 215 Py_INCREF(module); 216 } 217 return module; 218} 219 220static int 221update_registry(PyObject *registry, PyObject *text, PyObject *category, 222 int add_zero) 223{ 224 PyObject *altkey, *zero = NULL; 225 int rc; 226 227 if (add_zero) { 228 zero = PyInt_FromLong(0); 229 if (zero == NULL) 230 return -1; 231 altkey = PyTuple_Pack(3, text, category, zero); 232 } 233 else 234 altkey = PyTuple_Pack(2, text, category); 235 236 rc = already_warned(registry, altkey, 1); 237 Py_XDECREF(zero); 238 Py_XDECREF(altkey); 239 return rc; 240} 241 242static void 243show_warning(PyObject *filename, int lineno, PyObject *text, PyObject 244 *category, PyObject *sourceline) 245{ 246 PyObject *f_stderr; 247 PyObject *name; 248 char lineno_str[128]; 249 250 PyOS_snprintf(lineno_str, sizeof(lineno_str), ":%d: ", lineno); 251 252 name = PyObject_GetAttrString(category, "__name__"); 253 if (name == NULL) /* XXX Can an object lack a '__name__' attribute? */ 254 return; 255 256 f_stderr = PySys_GetObject("stderr"); 257 if (f_stderr == NULL) { 258 fprintf(stderr, "lost sys.stderr\n"); 259 Py_DECREF(name); 260 return; 261 } 262 263 /* Print "filename:lineno: category: text\n" */ 264 PyFile_WriteObject(filename, f_stderr, Py_PRINT_RAW); 265 PyFile_WriteString(lineno_str, f_stderr); 266 PyFile_WriteObject(name, f_stderr, Py_PRINT_RAW); 267 PyFile_WriteString(": ", f_stderr); 268 PyFile_WriteObject(text, f_stderr, Py_PRINT_RAW); 269 PyFile_WriteString("\n", f_stderr); 270 Py_XDECREF(name); 271 272 /* Print " source_line\n" */ 273 if (sourceline) { 274 char *source_line_str = PyString_AS_STRING(sourceline); 275 while (*source_line_str == ' ' || *source_line_str == '\t' || 276 *source_line_str == '\014') 277 source_line_str++; 278 279 PyFile_WriteString(source_line_str, f_stderr); 280 PyFile_WriteString("\n", f_stderr); 281 } 282 else 283 _Py_DisplaySourceLine(f_stderr, PyString_AS_STRING(filename), 284 lineno, 2); 285 PyErr_Clear(); 286} 287 288static PyObject * 289warn_explicit(PyObject *category, PyObject *message, 290 PyObject *filename, int lineno, 291 PyObject *module, PyObject *registry, PyObject *sourceline) 292{ 293 PyObject *key = NULL, *text = NULL, *result = NULL, *lineno_obj = NULL; 294 PyObject *item = Py_None; 295 const char *action; 296 int rc; 297 298 if (registry && !PyDict_Check(registry) && (registry != Py_None)) { 299 PyErr_SetString(PyExc_TypeError, "'registry' must be a dict"); 300 return NULL; 301 } 302 303 /* Normalize module. */ 304 if (module == NULL) { 305 module = normalize_module(filename); 306 if (module == NULL) 307 return NULL; 308 } 309 else 310 Py_INCREF(module); 311 312 /* Normalize message. */ 313 Py_INCREF(message); /* DECREF'ed in cleanup. */ 314 rc = PyObject_IsInstance(message, PyExc_Warning); 315 if (rc == -1) { 316 goto cleanup; 317 } 318 if (rc == 1) { 319 text = PyObject_Str(message); 320 if (text == NULL) 321 goto cleanup; 322 category = (PyObject*)message->ob_type; 323 } 324 else { 325 text = message; 326 message = PyObject_CallFunction(category, "O", message); 327 if (message == NULL) 328 goto cleanup; 329 } 330 331 lineno_obj = PyInt_FromLong(lineno); 332 if (lineno_obj == NULL) 333 goto cleanup; 334 335 /* Create key. */ 336 key = PyTuple_Pack(3, text, category, lineno_obj); 337 if (key == NULL) 338 goto cleanup; 339 340 if ((registry != NULL) && (registry != Py_None)) { 341 rc = already_warned(registry, key, 0); 342 if (rc == -1) 343 goto cleanup; 344 else if (rc == 1) 345 goto return_none; 346 /* Else this warning hasn't been generated before. */ 347 } 348 349 action = get_filter(category, text, lineno, module, &item); 350 if (action == NULL) 351 goto cleanup; 352 353 if (strcmp(action, "error") == 0) { 354 PyErr_SetObject(category, message); 355 goto cleanup; 356 } 357 358 /* Store in the registry that we've been here, *except* when the action 359 is "always". */ 360 rc = 0; 361 if (strcmp(action, "always") != 0) { 362 if (registry != NULL && registry != Py_None && 363 PyDict_SetItem(registry, key, Py_True) < 0) 364 goto cleanup; 365 else if (strcmp(action, "ignore") == 0) 366 goto return_none; 367 else if (strcmp(action, "once") == 0) { 368 if (registry == NULL || registry == Py_None) { 369 registry = get_once_registry(); 370 if (registry == NULL) 371 goto cleanup; 372 } 373 /* _once_registry[(text, category)] = 1 */ 374 rc = update_registry(registry, text, category, 0); 375 } 376 else if (strcmp(action, "module") == 0) { 377 /* registry[(text, category, 0)] = 1 */ 378 if (registry != NULL && registry != Py_None) 379 rc = update_registry(registry, text, category, 0); 380 } 381 else if (strcmp(action, "default") != 0) { 382 PyObject *to_str = PyObject_Str(item); 383 const char *err_str = "???"; 384 385 if (to_str != NULL) 386 err_str = PyString_AS_STRING(to_str); 387 PyErr_Format(PyExc_RuntimeError, 388 "Unrecognized action (%s) in warnings.filters:\n %s", 389 action, err_str); 390 Py_XDECREF(to_str); 391 goto cleanup; 392 } 393 } 394 395 if (rc == 1) /* Already warned for this module. */ 396 goto return_none; 397 if (rc == 0) { 398 PyObject *show_fxn = get_warnings_attr("showwarning"); 399 if (show_fxn == NULL) { 400 if (PyErr_Occurred()) 401 goto cleanup; 402 show_warning(filename, lineno, text, category, sourceline); 403 } 404 else { 405 PyObject *res; 406 407 if (!PyMethod_Check(show_fxn) && !PyFunction_Check(show_fxn)) { 408 PyErr_SetString(PyExc_TypeError, 409 "warnings.showwarning() must be set to a " 410 "function or method"); 411 Py_DECREF(show_fxn); 412 goto cleanup; 413 } 414 415 res = PyObject_CallFunctionObjArgs(show_fxn, message, category, 416 filename, lineno_obj, 417 NULL); 418 Py_DECREF(show_fxn); 419 Py_XDECREF(res); 420 if (res == NULL) 421 goto cleanup; 422 } 423 } 424 else /* if (rc == -1) */ 425 goto cleanup; 426 427 return_none: 428 result = Py_None; 429 Py_INCREF(result); 430 431 cleanup: 432 Py_XDECREF(key); 433 Py_XDECREF(text); 434 Py_XDECREF(lineno_obj); 435 Py_DECREF(module); 436 Py_XDECREF(message); 437 return result; /* Py_None or NULL. */ 438} 439 440/* filename, module, and registry are new refs, globals is borrowed */ 441/* Returns 0 on error (no new refs), 1 on success */ 442static int 443setup_context(Py_ssize_t stack_level, PyObject **filename, int *lineno, 444 PyObject **module, PyObject **registry) 445{ 446 PyObject *globals; 447 448 /* Setup globals and lineno. */ 449 PyFrameObject *f = PyThreadState_GET()->frame; 450 while (--stack_level > 0 && f != NULL) 451 f = f->f_back; 452 453 if (f == NULL) { 454 globals = PyThreadState_Get()->interp->sysdict; 455 *lineno = 1; 456 } 457 else { 458 globals = f->f_globals; 459 *lineno = PyFrame_GetLineNumber(f); 460 } 461 462 *module = NULL; 463 464 /* Setup registry. */ 465 assert(globals != NULL); 466 assert(PyDict_Check(globals)); 467 *registry = PyDict_GetItemString(globals, "__warningregistry__"); 468 if (*registry == NULL) { 469 int rc; 470 471 *registry = PyDict_New(); 472 if (*registry == NULL) 473 return 0; 474 475 rc = PyDict_SetItemString(globals, "__warningregistry__", *registry); 476 if (rc < 0) 477 goto handle_error; 478 } 479 else 480 Py_INCREF(*registry); 481 482 /* Setup module. */ 483 *module = PyDict_GetItemString(globals, "__name__"); 484 if (*module == NULL) { 485 *module = PyString_FromString("<string>"); 486 if (*module == NULL) 487 goto handle_error; 488 } 489 else 490 Py_INCREF(*module); 491 492 /* Setup filename. */ 493 *filename = PyDict_GetItemString(globals, "__file__"); 494 if (*filename != NULL && PyString_Check(*filename)) { 495 Py_ssize_t len = PyString_Size(*filename); 496 const char *file_str = PyString_AsString(*filename); 497 if (file_str == NULL || (len < 0 && PyErr_Occurred())) 498 goto handle_error; 499 500 /* if filename.lower().endswith((".pyc", ".pyo")): */ 501 if (len >= 4 && 502 file_str[len-4] == '.' && 503 tolower(file_str[len-3]) == 'p' && 504 tolower(file_str[len-2]) == 'y' && 505 (tolower(file_str[len-1]) == 'c' || 506 tolower(file_str[len-1]) == 'o')) 507 { 508 *filename = PyString_FromStringAndSize(file_str, len-1); 509 if (*filename == NULL) 510 goto handle_error; 511 } 512 else 513 Py_INCREF(*filename); 514 } 515 else { 516 const char *module_str = PyString_AsString(*module); 517 *filename = NULL; 518 if (module_str && strcmp(module_str, "__main__") == 0) { 519 PyObject *argv = PySys_GetObject("argv"); 520 if (argv != NULL && PyList_Size(argv) > 0) { 521 int is_true; 522 *filename = PyList_GetItem(argv, 0); 523 Py_INCREF(*filename); 524 /* If sys.argv[0] is false, then use '__main__'. */ 525 is_true = PyObject_IsTrue(*filename); 526 if (is_true < 0) { 527 Py_DECREF(*filename); 528 goto handle_error; 529 } 530 else if (!is_true) { 531 Py_DECREF(*filename); 532 *filename = PyString_FromString("__main__"); 533 if (*filename == NULL) 534 goto handle_error; 535 } 536 } 537 else { 538 /* embedded interpreters don't have sys.argv, see bug #839151 */ 539 *filename = PyString_FromString("__main__"); 540 if (*filename == NULL) 541 goto handle_error; 542 } 543 } 544 if (*filename == NULL) { 545 *filename = *module; 546 Py_INCREF(*filename); 547 } 548 } 549 550 return 1; 551 552 handle_error: 553 /* filename not XDECREF'ed here as there is no way to jump here with a 554 dangling reference. */ 555 Py_XDECREF(*registry); 556 Py_XDECREF(*module); 557 return 0; 558} 559 560static PyObject * 561get_category(PyObject *message, PyObject *category) 562{ 563 int rc; 564 565 /* Get category. */ 566 rc = PyObject_IsInstance(message, PyExc_Warning); 567 if (rc == -1) 568 return NULL; 569 570 if (rc == 1) 571 category = (PyObject*)message->ob_type; 572 else if (category == NULL) 573 category = PyExc_UserWarning; 574 575 /* Validate category. */ 576 rc = PyObject_IsSubclass(category, PyExc_Warning); 577 if (rc == -1) 578 return NULL; 579 if (rc == 0) { 580 PyErr_SetString(PyExc_ValueError, 581 "category is not a subclass of Warning"); 582 return NULL; 583 } 584 585 return category; 586} 587 588static PyObject * 589do_warn(PyObject *message, PyObject *category, Py_ssize_t stack_level) 590{ 591 PyObject *filename, *module, *registry, *res; 592 int lineno; 593 594 if (!setup_context(stack_level, &filename, &lineno, &module, ®istry)) 595 return NULL; 596 597 res = warn_explicit(category, message, filename, lineno, module, registry, 598 NULL); 599 Py_DECREF(filename); 600 Py_DECREF(registry); 601 Py_DECREF(module); 602 return res; 603} 604 605static PyObject * 606warnings_warn(PyObject *self, PyObject *args, PyObject *kwds) 607{ 608 static char *kw_list[] = { "message", "category", "stacklevel", 0 }; 609 PyObject *message, *category = NULL; 610 Py_ssize_t stack_level = 1; 611 612 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|On:warn", kw_list, 613 &message, &category, &stack_level)) 614 return NULL; 615 616 category = get_category(message, category); 617 if (category == NULL) 618 return NULL; 619 return do_warn(message, category, stack_level); 620} 621 622static PyObject * 623warnings_warn_explicit(PyObject *self, PyObject *args, PyObject *kwds) 624{ 625 static char *kwd_list[] = {"message", "category", "filename", "lineno", 626 "module", "registry", "module_globals", 0}; 627 PyObject *message; 628 PyObject *category; 629 PyObject *filename; 630 int lineno; 631 PyObject *module = NULL; 632 PyObject *registry = NULL; 633 PyObject *module_globals = NULL; 634 635 if (!PyArg_ParseTupleAndKeywords(args, kwds, "OOOi|OOO:warn_explicit", 636 kwd_list, &message, &category, &filename, &lineno, &module, 637 ®istry, &module_globals)) 638 return NULL; 639 640 if (module_globals) { 641 static PyObject *get_source_name = NULL; 642 static PyObject *splitlines_name = NULL; 643 PyObject *loader; 644 PyObject *module_name; 645 PyObject *source; 646 PyObject *source_list; 647 PyObject *source_line; 648 PyObject *returned; 649 650 if (get_source_name == NULL) { 651 get_source_name = PyString_InternFromString("get_source"); 652 if (!get_source_name) 653 return NULL; 654 } 655 if (splitlines_name == NULL) { 656 splitlines_name = PyString_InternFromString("splitlines"); 657 if (!splitlines_name) 658 return NULL; 659 } 660 661 /* Check/get the requisite pieces needed for the loader. */ 662 loader = PyDict_GetItemString(module_globals, "__loader__"); 663 module_name = PyDict_GetItemString(module_globals, "__name__"); 664 665 if (loader == NULL || module_name == NULL) 666 goto standard_call; 667 668 /* Make sure the loader implements the optional get_source() method. */ 669 if (!PyObject_HasAttrString(loader, "get_source")) 670 goto standard_call; 671 /* Call get_source() to get the source code. */ 672 source = PyObject_CallMethodObjArgs(loader, get_source_name, 673 module_name, NULL); 674 if (!source) 675 return NULL; 676 else if (source == Py_None) { 677 Py_DECREF(Py_None); 678 goto standard_call; 679 } 680 681 /* Split the source into lines. */ 682 source_list = PyObject_CallMethodObjArgs(source, splitlines_name, 683 NULL); 684 Py_DECREF(source); 685 if (!source_list) 686 return NULL; 687 688 /* Get the source line. */ 689 source_line = PyList_GetItem(source_list, lineno-1); 690 if (!source_line) { 691 Py_DECREF(source_list); 692 return NULL; 693 } 694 695 /* Handle the warning. */ 696 returned = warn_explicit(category, message, filename, lineno, module, 697 registry, source_line); 698 Py_DECREF(source_list); 699 return returned; 700 } 701 702 standard_call: 703 return warn_explicit(category, message, filename, lineno, module, 704 registry, NULL); 705} 706 707 708/* Function to issue a warning message; may raise an exception. */ 709int 710PyErr_WarnEx(PyObject *category, const char *text, Py_ssize_t stack_level) 711{ 712 PyObject *res; 713 PyObject *message = PyString_FromString(text); 714 if (message == NULL) 715 return -1; 716 717 if (category == NULL) 718 category = PyExc_RuntimeWarning; 719 720 res = do_warn(message, category, stack_level); 721 Py_DECREF(message); 722 if (res == NULL) 723 return -1; 724 Py_DECREF(res); 725 726 return 0; 727} 728 729/* PyErr_Warn is only for backwards compatibility and will be removed. 730 Use PyErr_WarnEx instead. */ 731 732#undef PyErr_Warn 733 734PyAPI_FUNC(int) 735PyErr_Warn(PyObject *category, char *text) 736{ 737 return PyErr_WarnEx(category, text, 1); 738} 739 740/* Warning with explicit origin */ 741int 742PyErr_WarnExplicit(PyObject *category, const char *text, 743 const char *filename_str, int lineno, 744 const char *module_str, PyObject *registry) 745{ 746 PyObject *res; 747 PyObject *message = PyString_FromString(text); 748 PyObject *filename = PyString_FromString(filename_str); 749 PyObject *module = NULL; 750 int ret = -1; 751 752 if (message == NULL || filename == NULL) 753 goto exit; 754 if (module_str != NULL) { 755 module = PyString_FromString(module_str); 756 if (module == NULL) 757 goto exit; 758 } 759 760 if (category == NULL) 761 category = PyExc_RuntimeWarning; 762 res = warn_explicit(category, message, filename, lineno, module, registry, 763 NULL); 764 if (res == NULL) 765 goto exit; 766 Py_DECREF(res); 767 ret = 0; 768 769 exit: 770 Py_XDECREF(message); 771 Py_XDECREF(module); 772 Py_XDECREF(filename); 773 return ret; 774} 775 776 777PyDoc_STRVAR(warn_doc, 778"Issue a warning, or maybe ignore it or raise an exception."); 779 780PyDoc_STRVAR(warn_explicit_doc, 781"Low-level inferface to warnings functionality."); 782 783static PyMethodDef warnings_functions[] = { 784 {"warn", (PyCFunction)warnings_warn, METH_VARARGS | METH_KEYWORDS, 785 warn_doc}, 786 {"warn_explicit", (PyCFunction)warnings_warn_explicit, 787 METH_VARARGS | METH_KEYWORDS, warn_explicit_doc}, 788 /* XXX(brett.cannon): add showwarning? */ 789 /* XXX(brett.cannon): Reasonable to add formatwarning? */ 790 {NULL, NULL} /* sentinel */ 791}; 792 793 794static PyObject * 795create_filter(PyObject *category, const char *action) 796{ 797 static PyObject *ignore_str = NULL; 798 static PyObject *error_str = NULL; 799 static PyObject *default_str = NULL; 800 PyObject *action_obj = NULL; 801 PyObject *lineno, *result; 802 803 if (!strcmp(action, "ignore")) { 804 if (ignore_str == NULL) { 805 ignore_str = PyString_InternFromString("ignore"); 806 if (ignore_str == NULL) 807 return NULL; 808 } 809 action_obj = ignore_str; 810 } 811 else if (!strcmp(action, "error")) { 812 if (error_str == NULL) { 813 error_str = PyString_InternFromString("error"); 814 if (error_str == NULL) 815 return NULL; 816 } 817 action_obj = error_str; 818 } 819 else if (!strcmp(action, "default")) { 820 if (default_str == NULL) { 821 default_str = PyString_InternFromString("default"); 822 if (default_str == NULL) 823 return NULL; 824 } 825 action_obj = default_str; 826 } 827 else { 828 Py_FatalError("unknown action"); 829 } 830 831 /* This assumes the line number is zero for now. */ 832 lineno = PyInt_FromLong(0); 833 if (lineno == NULL) 834 return NULL; 835 result = PyTuple_Pack(5, action_obj, Py_None, category, Py_None, lineno); 836 Py_DECREF(lineno); 837 return result; 838} 839 840static PyObject * 841init_filters(void) 842{ 843 /* Don't silence DeprecationWarning if -3 or -Q were used. */ 844 PyObject *filters = PyList_New(Py_Py3kWarningFlag || 845 Py_DivisionWarningFlag ? 3 : 4); 846 unsigned int pos = 0; /* Post-incremented in each use. */ 847 unsigned int x; 848 const char *bytes_action; 849 850 if (filters == NULL) 851 return NULL; 852 853 /* If guard changes, make sure to update 'filters' initialization above. */ 854 if (!Py_Py3kWarningFlag && !Py_DivisionWarningFlag) { 855 PyList_SET_ITEM(filters, pos++, 856 create_filter(PyExc_DeprecationWarning, "ignore")); 857 } 858 PyList_SET_ITEM(filters, pos++, 859 create_filter(PyExc_PendingDeprecationWarning, "ignore")); 860 PyList_SET_ITEM(filters, pos++, 861 create_filter(PyExc_ImportWarning, "ignore")); 862 if (Py_BytesWarningFlag > 1) 863 bytes_action = "error"; 864 else if (Py_BytesWarningFlag) 865 bytes_action = "default"; 866 else 867 bytes_action = "ignore"; 868 PyList_SET_ITEM(filters, pos++, create_filter(PyExc_BytesWarning, 869 bytes_action)); 870 871 for (x = 0; x < pos; x += 1) { 872 if (PyList_GET_ITEM(filters, x) == NULL) { 873 Py_DECREF(filters); 874 return NULL; 875 } 876 } 877 878 return filters; 879} 880 881 882PyMODINIT_FUNC 883_PyWarnings_Init(void) 884{ 885 PyObject *m; 886 887 m = Py_InitModule3(MODULE_NAME, warnings_functions, warnings__doc__); 888 if (m == NULL) 889 return; 890 891 _filters = init_filters(); 892 if (_filters == NULL) 893 return; 894 Py_INCREF(_filters); 895 if (PyModule_AddObject(m, "filters", _filters) < 0) 896 return; 897 898 _once_registry = PyDict_New(); 899 if (_once_registry == NULL) 900 return; 901 Py_INCREF(_once_registry); 902 if (PyModule_AddObject(m, "once_registry", _once_registry) < 0) 903 return; 904 905 _default_action = PyString_FromString("default"); 906 if (_default_action == NULL) 907 return; 908 Py_INCREF(_default_action); 909 if (PyModule_AddObject(m, "default_action", _default_action) < 0) 910 return; 911} 912