Python/_warnings.c

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