1 #include "Python.h"

     2 #include "code.h"  /* For DeprecationWarning about adding 'line'. */

     3 #include "frameobject.h"

     4 

     5 #define MODULE_NAME "_warnings"

     6 #define DEFAULT_ACTION_NAME "default_action"

     7 

     8 PyDoc_STRVAR(warnings__doc__,

     9 MODULE_NAME " provides basic warning filtering support.\n"

    10 "It is a helper module to speed up interpreter start-up.");

    11 

    12 /* Both 'filters' and 'onceregistry' can be set in warnings.py;

    13    get_warnings_attr() will reset these variables accordingly. */

    14 static PyObject *_filters;  /* List */

    15 static PyObject *_once_registry;  /* Dict */

    16 

    17 

    18 static int

    19 check_matched(PyObject *obj, PyObject *arg)

    20 {

    21     PyObject *result;

    22     int rc;

    23 

    24     if (obj == Py_None)

    25         return 1;

    26     result = PyObject_CallMethod(obj, "match", "O", arg);

    27     if (result == NULL)

    28         return -1;

    29 

    30     rc = PyObject_IsTrue(result);

    31     Py_DECREF(result);

    32     return rc;

    33 }

    34 

    35 /*

    36    Returns a new reference.

    37    A NULL return value can mean false or an error.

    38 */

    39 static PyObject *

    40 get_warnings_attr(const char *attr)

    41 {

    42     static PyObject *warnings_str = NULL;

    43     PyObject *all_modules;

    44     PyObject *warnings_module;

    45     int result;

    46 

    47     if (warnings_str == NULL) {

    48         warnings_str = PyString_InternFromString("warnings");

    49         if (warnings_str == NULL)

    50             return NULL;

    51     }

    52 

    53     all_modules = PyImport_GetModuleDict();

    54     result = PyDict_Contains(all_modules, warnings_str);

    55     if (result == -1 || result == 0)

    56         return NULL;

    57 

    58     warnings_module = PyDict_GetItem(all_modules, warnings_str);

    59     if (!PyObject_HasAttrString(warnings_module, attr))

    60             return NULL;

    61     return PyObject_GetAttrString(warnings_module, attr);

    62 }

    63 

    64 

    65 static PyObject *

    66 get_once_registry(void)

    67 {

    68     PyObject *registry;

    69 

    70     registry = get_warnings_attr("onceregistry");

    71     if (registry == NULL) {

    72         if (PyErr_Occurred())

    73             return NULL;

    74         return _once_registry;

    75     }

    76     Py_DECREF(_once_registry);

    77     _once_registry = registry;

    78     return registry;

    79 }

    80 

    81 

    82 /* The item is a borrowed reference. */

    83 static const char *

    84 get_filter(PyObject *category, PyObject *text, Py_ssize_t lineno,

    85            PyObject *module, PyObject **item)

    86 {

    87     PyObject *action, *m, *d;

    88     Py_ssize_t i;

    89     PyObject *warnings_filters;

    90 

    91     warnings_filters = get_warnings_attr("filters");

    92     if (warnings_filters == NULL) {

    93         if (PyErr_Occurred())

    94             return NULL;

    95     }

    96     else {

    97         Py_DECREF(_filters);

    98         _filters = warnings_filters;

    99     }

   100 

   101     if (!PyList_Check(_filters)) {

   102         PyErr_SetString(PyExc_ValueError,

   103                         MODULE_NAME ".filters must be a list");

   104         return NULL;

   105     }

   106 

   107     /* _filters could change while we are iterating over it. */

   108     for (i = 0; i < PyList_GET_SIZE(_filters); i++) {

   109         PyObject *tmp_item, *action, *msg, *cat, *mod, *ln_obj;

   110         Py_ssize_t ln;

   111         int is_subclass, good_msg, good_mod;

   112 

   113         tmp_item = *item = PyList_GET_ITEM(_filters, i);

   114         if (PyTuple_Size(tmp_item) != 5) {

   115             PyErr_Format(PyExc_ValueError,

   116                          MODULE_NAME ".filters item %zd isn't a 5-tuple", i);

   117             return NULL;

   118         }

   119 

   120         /* Python code: action, msg, cat, mod, ln = item */

   121         action = PyTuple_GET_ITEM(tmp_item, 0);

   122         msg = PyTuple_GET_ITEM(tmp_item, 1);

   123         cat = PyTuple_GET_ITEM(tmp_item, 2);

   124         mod = PyTuple_GET_ITEM(tmp_item, 3);

   125         ln_obj = PyTuple_GET_ITEM(tmp_item, 4);

   126 

   127         good_msg = check_matched(msg, text);

   128         good_mod = check_matched(mod, module);

   129         is_subclass = PyObject_IsSubclass(category, cat);

   130         ln = PyInt_AsSsize_t(ln_obj);

   131         if (good_msg == -1 || good_mod == -1 || is_subclass == -1 ||

   132             (ln == -1 && PyErr_Occurred()))

   133             return NULL;

   134 

   135         if (good_msg && is_subclass && good_mod && (ln == 0 || lineno == ln))

   136             return PyString_AsString(action);

   137     }

   138 

   139     m = PyImport_ImportModule(MODULE_NAME);

   140     if (m == NULL)

   141         return NULL;

   142     d = PyModule_GetDict(m);

   143     Py_DECREF(m);

   144     if (d == NULL)

   145         return NULL;

   146     action = PyDict_GetItemString(d, DEFAULT_ACTION_NAME);

   147     if (action != NULL)

   148         return PyString_AsString(action);

   149 

   150     PyErr_SetString(PyExc_ValueError,

   151                     MODULE_NAME "." DEFAULT_ACTION_NAME " not found");

   152     return NULL;

   153 }

   154 

   155 static int

   156 already_warned(PyObject *registry, PyObject *key, int should_set)

   157 {

   158     PyObject *already_warned;

   159 

   160     if (key == NULL)

   161         return -1;

   162 

   163     already_warned = PyDict_GetItem(registry, key);

   164     if (already_warned != NULL) {

   165         int rc = PyObject_IsTrue(already_warned);

   166         if (rc != 0)

   167             return rc;

   168     }

   169 

   170     /* This warning wasn't found in the registry, set it. */

   171     if (should_set)

   172         return PyDict_SetItem(registry, key, Py_True);

   173     return 0;

   174 }

   175 

   176 /* New reference. */

   177 static PyObject *

   178 normalize_module(PyObject *filename)

   179 {

   180     PyObject *module;

   181     const char *mod_str;

   182     Py_ssize_t len;

   183 

   184     int rc = PyObject_IsTrue(filename);

   185     if (rc == -1)

   186         return NULL;

   187     else if (rc == 0)

   188         return PyString_FromString("<unknown>");

   189 

   190     mod_str = PyString_AsString(filename);

   191     if (mod_str == NULL)

   192 	    return NULL;

   193     len = PyString_Size(filename);

   194     if (len < 0)

   195         return NULL;

   196     if (len >= 3 &&

   197 	strncmp(mod_str + (len - 3), ".py", 3) == 0) {

   198         module = PyString_FromStringAndSize(mod_str, len-3);

   199     }

   200     else {

   201         module = filename;

   202         Py_INCREF(module);

   203     }

   204     return module;

   205 }

   206 

   207 static int

   208 update_registry(PyObject *registry, PyObject *text, PyObject *category,

   209                 int add_zero)

   210 {

   211     PyObject *altkey, *zero = NULL;

   212     int rc;

   213 

   214     if (add_zero) {

   215         zero = PyInt_FromLong(0);

   216         if (zero == NULL)

   217             return -1;

   218         altkey = PyTuple_Pack(3, text, category, zero);

   219     }

   220     else

   221         altkey = PyTuple_Pack(2, text, category);

   222 

   223     rc = already_warned(registry, altkey, 1);

   224     Py_XDECREF(zero);

   225     Py_XDECREF(altkey);

   226     return rc;

   227 }

   228 

   229 static void

   230 show_warning(PyObject *filename, int lineno, PyObject *text, PyObject

   231                 *category, PyObject *sourceline)

   232 {

   233     PyObject *f_stderr;

   234     PyObject *name;

   235     char lineno_str[128];

   236 

   237     PyOS_snprintf(lineno_str, sizeof(lineno_str), ":%d: ", lineno);

   238 

   239     name = PyObject_GetAttrString(category, "__name__");

   240     if (name == NULL)  /* XXX Can an object lack a '__name__' attribute? */

   241 	    return;

   242 

   243     f_stderr = PySys_GetObject("stderr");

   244     if (f_stderr == NULL) {

   245         fprintf(stderr, "lost sys.stderr\n");

   246         Py_DECREF(name);

   247         return;

   248     }

   249 

   250     /* Print "filename:lineno: category: text\n" */

   251     PyFile_WriteObject(filename, f_stderr, Py_PRINT_RAW);

   252     PyFile_WriteString(lineno_str, f_stderr);

   253     PyFile_WriteObject(name, f_stderr, Py_PRINT_RAW);

   254     PyFile_WriteString(": ", f_stderr);

   255     PyFile_WriteObject(text, f_stderr, Py_PRINT_RAW);

   256     PyFile_WriteString("\n", f_stderr);

   257     Py_XDECREF(name);

   258 

   259     /* Print "  source_line\n" */

   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), 

   271                               lineno, 2);

   272     PyErr_Clear();

   273 }

   274 

   275 static PyObject *

   276 warn_explicit(PyObject *category, PyObject *message,

   277               PyObject *filename, int lineno,

   278               PyObject *module, PyObject *registry, PyObject *sourceline)

   279 {

   280     PyObject *key = NULL, *text = NULL, *result = NULL, *lineno_obj = NULL;

   281     PyObject *item = Py_None;

   282     const char *action;

   283     int rc;

   284     

   285     if (registry && !PyDict_Check(registry) && (registry != Py_None)) {

   286         PyErr_SetString(PyExc_TypeError, "'registry' must be a dict");

   287         return NULL;

   288     }

   289 

   290     /* Normalize module. */

   291     if (module == NULL) {

   292         module = normalize_module(filename);

   293         if (module == NULL)

   294             return NULL;

   295     }

   296     else

   297         Py_INCREF(module);

   298 

   299     /* Normalize message. */

   300     Py_INCREF(message);  /* DECREF'ed in cleanup. */

   301     rc = PyObject_IsInstance(message, PyExc_Warning);

   302     if (rc == -1) {

   303         goto cleanup;

   304     }

   305     if (rc == 1) {

   306         text = PyObject_Str(message);

   307         category = (PyObject*)message->ob_type;

   308     }

   309     else {

   310         text = message;

   311         message = PyObject_CallFunction(category, "O", message);

   312         if (message == NULL)

   313             goto cleanup;

   314     }

   315 

   316     lineno_obj = PyInt_FromLong(lineno);

   317     if (lineno_obj == NULL)

   318         goto cleanup;

   319 

   320     /* Create key. */

   321     key = PyTuple_Pack(3, text, category, lineno_obj);

   322     if (key == NULL)

   323         goto cleanup;

   324 

   325     if ((registry != NULL) && (registry != Py_None)) {

   326         rc = already_warned(registry, key, 0);

   327         if (rc == -1)

   328             goto cleanup;

   329 	else if (rc == 1)

   330             goto return_none;

   331         /* Else this warning hasn't been generated before. */

   332     }

   333 

   334     action = get_filter(category, text, lineno, module, &item);

   335     if (action == NULL)

   336         goto cleanup;

   337 

   338     if (strcmp(action, "error") == 0) {

   339         PyErr_SetObject(category, message);

   340         goto cleanup;

   341     }

   342 

   343     /* Store in the registry that we've been here, *except* when the action

   344        is "always". */

   345     rc = 0;

   346     if (strcmp(action, "always") != 0) {

   347         if (registry != NULL && registry != Py_None &&

   348                 PyDict_SetItem(registry, key, Py_True) < 0)

   349             goto cleanup;

   350         else if (strcmp(action, "ignore") == 0)

   351             goto return_none;

   352         else if (strcmp(action, "once") == 0) {

   353             if (registry == NULL || registry == Py_None) {

   354                 registry = get_once_registry();

   355                 if (registry == NULL)

   356                     goto cleanup;

   357             }

   358             /* _once_registry[(text, category)] = 1 */

   359             rc = update_registry(registry, text, category, 0);

   360         }

   361         else if (strcmp(action, "module") == 0) {

   362             /* registry[(text, category, 0)] = 1 */

   363             if (registry != NULL && registry != Py_None)

   364                 rc = update_registry(registry, text, category, 0);

   365         }

   366         else if (strcmp(action, "default") != 0) {

   367             PyObject *to_str = PyObject_Str(item);

   368             const char *err_str = "???";

   369 

   370             if (to_str != NULL)

   371                 err_str = PyString_AS_STRING(to_str);

   372             PyErr_Format(PyExc_RuntimeError,

   373                         "Unrecognized action (%s) in warnings.filters:\n %s",

   374                         action, err_str);

   375             Py_XDECREF(to_str);

   376             goto cleanup;

   377         }

   378     }

   379 

   380     if (rc == 1)  /* Already warned for this module. */

   381         goto return_none;

   382     if (rc == 0) {

   383         PyObject *show_fxn = get_warnings_attr("showwarning");

   384         if (show_fxn == NULL) {

   385             if (PyErr_Occurred())

   386                 goto cleanup;

   387             show_warning(filename, lineno, text, category, sourceline);

   388         }

   389         else {

   390             const char *msg = "functions overriding warnings.showwarning() "

   391                                 "must support the 'line' argument";

   392             const char *text_char = PyString_AS_STRING(text);

   393 

   394             if (strcmp(msg, text_char) == 0) {

   395                 /* Prevent infinite recursion by using built-in implementation

   396                    of showwarning(). */

   397                 show_warning(filename, lineno, text, category, sourceline);

   398             }

   399             else {

   400                 PyObject *check_fxn;

   401                 PyObject *defaults;

   402                 PyObject *res;

   403 

   404                 if (PyMethod_Check(show_fxn))

   405                     check_fxn = PyMethod_Function(show_fxn);

   406                 else if (PyFunction_Check(show_fxn))

   407                     check_fxn = show_fxn;

   408                 else {

   409                     PyErr_SetString(PyExc_TypeError,

   410                                     "warnings.showwarning() must be set to a "

   411                                     "function or method");

   412                     Py_DECREF(show_fxn);

   413                     goto cleanup;

   414                 }

   415 

   416                 defaults = PyFunction_GetDefaults(check_fxn);

   417                 /* A proper implementation of warnings.showwarning() should

   418                     have at least two default arguments. */

   419                 if ((defaults == NULL) || (PyTuple_Size(defaults) < 2)) {

   420 	            PyCodeObject *code = (PyCodeObject *)

   421 						PyFunction_GetCode(check_fxn);

   422 		    if (!(code->co_flags & CO_VARARGS)) {

   423 		        if (PyErr_WarnEx(PyExc_DeprecationWarning, msg, 1) <

   424 				0) {

   425                             Py_DECREF(show_fxn);

   426                             goto cleanup;

   427                         }

   428                     }

   429 		}

   430                 res = PyObject_CallFunctionObjArgs(show_fxn, message, category,

   431                                                     filename, lineno_obj,

   432                                                     NULL);

   433                 Py_DECREF(show_fxn);

   434                 Py_XDECREF(res);

   435                 if (res == NULL)

   436                     goto cleanup;

   437             }

   438         }

   439     }

   440     else /* if (rc == -1) */

   441         goto cleanup;

   442 

   443  return_none:

   444     result = Py_None;

   445     Py_INCREF(result);

   446 

   447  cleanup:

   448     Py_XDECREF(key);

   449     Py_XDECREF(text);

   450     Py_XDECREF(lineno_obj);

   451     Py_DECREF(module);

   452     Py_XDECREF(message);

   453     return result;  /* Py_None or NULL. */

   454 }

   455 

   456 /* filename, module, and registry are new refs, globals is borrowed */

   457 /* Returns 0 on error (no new refs), 1 on success */

   458 static int

   459 setup_context(Py_ssize_t stack_level, PyObject **filename, int *lineno,

   460               PyObject **module, PyObject **registry)

   461 {

   462     PyObject *globals;

   463 

   464     /* Setup globals and lineno. */

   465     PyFrameObject *f = PyThreadState_GET()->frame;

   466     while (--stack_level > 0 && f != NULL)

   467         f = f->f_back;

   468 

   469     if (f == NULL) {

   470         globals = PyThreadState_Get()->interp->sysdict;

   471         *lineno = 1;

   472     }

   473     else {

   474         globals = f->f_globals;

   475         *lineno = PyCode_Addr2Line(f->f_code, f->f_lasti);

   476     }

   477 

   478     *module = NULL;

   479 

   480     /* Setup registry. */

   481     assert(globals != NULL);

   482     assert(PyDict_Check(globals));

   483     *registry = PyDict_GetItemString(globals, "__warningregistry__");

   484     if (*registry == NULL) {

   485         int rc;

   486 

   487         *registry = PyDict_New();

   488         if (*registry == NULL)

   489             return 0;

   490 

   491          rc = PyDict_SetItemString(globals, "__warningregistry__", *registry);

   492          if (rc < 0)

   493             goto handle_error;

   494     }

   495     else

   496         Py_INCREF(*registry);

   497 

   498     /* Setup module. */

   499     *module = PyDict_GetItemString(globals, "__name__");

   500     if (*module == NULL) {

   501         *module = PyString_FromString("<string>");

   502         if (*module == NULL)

   503             goto handle_error;

   504     }

   505     else

   506         Py_INCREF(*module);

   507 

   508     /* Setup filename. */

   509     *filename = PyDict_GetItemString(globals, "__file__");

   510     if (*filename != NULL) {

   511 	    Py_ssize_t len = PyString_Size(*filename);

   512         const char *file_str = PyString_AsString(*filename);

   513 	    if (file_str == NULL || (len < 0 && PyErr_Occurred()))

   514             goto handle_error;

   515 

   516         /* if filename.lower().endswith((".pyc", ".pyo")): */

   517         if (len >= 4 &&

   518             file_str[len-4] == '.' &&

   519             tolower(file_str[len-3]) == 'p' &&

   520             tolower(file_str[len-2]) == 'y' &&

   521             (tolower(file_str[len-1]) == 'c' ||

   522                 tolower(file_str[len-1]) == 'o'))

   523         {

   524             *filename = PyString_FromStringAndSize(file_str, len-1);

   525 	        if (*filename == NULL)

   526 		        goto handle_error;

   527 	    }

   528 	    else

   529             Py_INCREF(*filename);

   530     }

   531     else {

   532         const char *module_str = PyString_AsString(*module);

   533         if (module_str && strcmp(module_str, "__main__") == 0) {

   534             PyObject *argv = PySys_GetObject("argv");

   535             if (argv != NULL && PyList_Size(argv) > 0) {

   536                 int is_true;

   537                 *filename = PyList_GetItem(argv, 0);

   538                 Py_INCREF(*filename);

   539                 /* If sys.argv[0] is false, then use '__main__'. */

   540                 is_true = PyObject_IsTrue(*filename);

   541                 if (is_true < 0) {

   542                     Py_DECREF(*filename);

   543                     goto handle_error;

   544                 }

   545                 else if (!is_true) {

   546                     Py_DECREF(*filename);

   547                     *filename = PyString_FromString("__main__");

   548                     if (*filename == NULL)

   549                         goto handle_error;

   550                 }

   551             }

   552             else {

   553                 /* embedded interpreters don't have sys.argv, see bug #839151 */

   554                 *filename = PyString_FromString("__main__");

   555 	            if (*filename == NULL)

   556 	                goto handle_error;

   557             }

   558         }

   559         if (*filename == NULL) {

   560             *filename = *module;

   561             Py_INCREF(*filename);

   562         }

   563     }

   564 

   565     return 1;

   566 

   567  handle_error:

   568     /* filename not XDECREF'ed here as there is no way to jump here with a

   569        dangling reference. */

   570     Py_XDECREF(*registry);

   571     Py_XDECREF(*module);

   572     return 0;

   573 }

   574 

   575 static PyObject *

   576 get_category(PyObject *message, PyObject *category)

   577 {

   578     int rc;

   579 

   580     /* Get category. */

   581     rc = PyObject_IsInstance(message, PyExc_Warning);

   582     if (rc == -1)

   583         return NULL;

   584 

   585     if (rc == 1)

   586         category = (PyObject*)message->ob_type;

   587     else if (category == NULL)

   588         category = PyExc_UserWarning;

   589 

   590     /* Validate category. */

   591     rc = PyObject_IsSubclass(category, PyExc_Warning);

   592     if (rc == -1)

   593         return NULL;

   594     if (rc == 0) {

   595         PyErr_SetString(PyExc_ValueError,

   596                         "category is not a subclass of Warning");

   597         return NULL;

   598     }

   599 

   600     return category;

   601 }

   602 

   603 static PyObject *

   604 do_warn(PyObject *message, PyObject *category, Py_ssize_t stack_level)

   605 {

   606     PyObject *filename, *module, *registry, *res;

   607     int lineno;

   608 

   609     if (!setup_context(stack_level, &filename, &lineno, &module, &registry))

   610         return NULL;

   611 

   612     res = warn_explicit(category, message, filename, lineno, module, registry,

   613                         NULL);

   614     Py_DECREF(filename);

   615     Py_DECREF(registry);

   616     Py_DECREF(module);

   617     return res;

   618 }

   619 

   620 static PyObject *

   621 warnings_warn(PyObject *self, PyObject *args, PyObject *kwds)

   622 {

   623     static char *kw_list[] = { "message", "category", "stacklevel", 0 };

   624     PyObject *message, *category = NULL;

   625     Py_ssize_t stack_level = 1;

   626 

   627     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|On:warn", kw_list,

   628                                      &message, &category, &stack_level))

   629         return NULL;

   630 

   631     category = get_category(message, category);

   632     if (category == NULL)

   633         return NULL;

   634     return do_warn(message, category, stack_level);

   635 }

   636 

   637 static PyObject *

   638 warnings_warn_explicit(PyObject *self, PyObject *args, PyObject *kwds)

   639 {

   640     static char *kwd_list[] = {"message", "category", "filename", "lineno",

   641                                 "module", "registry", "module_globals", 0};

   642     PyObject *message;

   643     PyObject *category;

   644     PyObject *filename;

   645     int lineno;

   646     PyObject *module = NULL;

   647     PyObject *registry = NULL;

   648     PyObject *module_globals = NULL;

   649 

   650     if (!PyArg_ParseTupleAndKeywords(args, kwds, "OOOi|OOO:warn_explicit",

   651                 kwd_list, &message, &category, &filename, &lineno, &module,

   652                 &registry, &module_globals))

   653         return NULL;

   654 

   655     if (module_globals) {

   656         static PyObject *get_source_name = NULL;

   657         static PyObject *splitlines_name = NULL;

   658         PyObject *loader;

   659         PyObject *module_name;

   660         PyObject *source;

   661         PyObject *source_list;

   662         PyObject *source_line;

   663         PyObject *returned;

   664 

   665         if (get_source_name == NULL) {

   666             get_source_name = PyString_InternFromString("get_source");

   667             if (!get_source_name)

   668                 return NULL;

   669         }

   670         if (splitlines_name == NULL) {

   671             splitlines_name = PyString_InternFromString("splitlines");

   672             if (!splitlines_name)

   673                 return NULL;

   674         }

   675 

   676         /* Check/get the requisite pieces needed for the loader. */

   677         loader = PyDict_GetItemString(module_globals, "__loader__");

   678         module_name = PyDict_GetItemString(module_globals, "__name__");

   679 

   680         if (loader == NULL || module_name == NULL)

   681             goto standard_call;

   682 

   683         /* Make sure the loader implements the optional get_source() method. */

   684         if (!PyObject_HasAttrString(loader, "get_source"))

   685                 goto standard_call;

   686         /* Call get_source() to get the source code. */

   687         source = PyObject_CallMethodObjArgs(loader, get_source_name,

   688                                                 module_name, NULL);

   689         if (!source)

   690             return NULL;

   691         else if (source == Py_None) {

   692             Py_DECREF(Py_None);

   693             goto standard_call;

   694         }

   695 

   696         /* Split the source into lines. */

   697         source_list = PyObject_CallMethodObjArgs(source, splitlines_name,

   698                                                     NULL);

   699         Py_DECREF(source);

   700         if (!source_list)

   701             return NULL;

   702 

   703         /* Get the source line. */

   704         source_line = PyList_GetItem(source_list, lineno-1);

   705         if (!source_line) {

   706             Py_DECREF(source_list);

   707             return NULL;

   708         }

   709 

   710         /* Handle the warning. */

   711         returned = warn_explicit(category, message, filename, lineno, module,

   712                             registry, source_line);

   713         Py_DECREF(source_list);

   714         return returned;

   715     }

   716 

   717  standard_call:

   718     return warn_explicit(category, message, filename, lineno, module,

   719                                 registry, NULL);

   720 }

   721 

   722 

   723 /* Function to issue a warning message; may raise an exception. */

   724 int

   725 PyErr_WarnEx(PyObject *category, const char *text, Py_ssize_t stack_level)

   726 {

   727     PyObject *res;

   728     PyObject *message = PyString_FromString(text);

   729     if (message == NULL)

   730         return -1;

   731 

   732     if (category == NULL)

   733         category = PyExc_RuntimeWarning;

   734 

   735     res = do_warn(message, category, stack_level);

   736     Py_DECREF(message);

   737     if (res == NULL)

   738         return -1;

   739     Py_DECREF(res);

   740 

   741     return 0;

   742 }

   743 

   744 /* PyErr_Warn is only for backwards compatability and will be removed.

   745    Use PyErr_WarnEx instead. */

   746 

   747 #undef PyErr_Warn

   748 

   749 PyAPI_FUNC(int)

   750 PyErr_Warn(PyObject *category, char *text)

   751 {

   752     return PyErr_WarnEx(category, text, 1);

   753 }

   754 

   755 /* Warning with explicit origin */

   756 int

   757 PyErr_WarnExplicit(PyObject *category, const char *text,

   758                    const char *filename_str, int lineno,

   759                    const char *module_str, PyObject *registry)

   760 {

   761     PyObject *res;

   762     PyObject *message = PyString_FromString(text);

   763     PyObject *filename = PyString_FromString(filename_str);

   764     PyObject *module = NULL;

   765     int ret = -1;

   766 

   767     if (message == NULL || filename == NULL)

   768         goto exit;

   769     if (module_str != NULL) {

   770         module = PyString_FromString(module_str);

   771             if (module == NULL)

   772                 goto exit;

   773     }

   774 

   775     if (category == NULL)

   776         category = PyExc_RuntimeWarning;

   777     res = warn_explicit(category, message, filename, lineno, module, registry,

   778                         NULL);

   779     if (res == NULL)

   780         goto exit;

   781     Py_DECREF(res);

   782     ret = 0;

   783 

   784  exit:

   785     Py_XDECREF(message);

   786     Py_XDECREF(module);

   787     Py_XDECREF(filename);

   788     return ret;

   789 }

   790 

   791 

   792 PyDoc_STRVAR(warn_doc,

   793 "Issue a warning, or maybe ignore it or raise an exception.");

   794 

   795 PyDoc_STRVAR(warn_explicit_doc,

   796 "Low-level inferface to warnings functionality.");

   797 

   798 static PyMethodDef warnings_functions[] = {

   799     {"warn", (PyCFunction)warnings_warn, METH_VARARGS | METH_KEYWORDS,

   800         warn_doc},

   801     {"warn_explicit", (PyCFunction)warnings_warn_explicit,

   802         METH_VARARGS | METH_KEYWORDS, warn_explicit_doc},

   803     /* XXX(brett.cannon): add showwarning? */

   804     /* XXX(brett.cannon): Reasonable to add formatwarning? */

   805     {NULL, NULL}	        /* sentinel */

   806 };

   807 

   808 

   809 static PyObject *

   810 create_filter(PyObject *category, const char *action)

   811 {

   812     static PyObject *ignore_str = NULL;

   813     static PyObject *error_str = NULL;

   814     static PyObject *default_str = NULL;

   815     PyObject *action_obj = NULL;

   816     PyObject *lineno, *result;

   817 

   818     if (!strcmp(action, "ignore")) {

   819         if (ignore_str == NULL) {

   820             ignore_str = PyString_InternFromString("ignore");

   821             if (ignore_str == NULL)

   822                 return NULL;

   823         }

   824         action_obj = ignore_str;

   825     }

   826     else if (!strcmp(action, "error")) {

   827         if (error_str == NULL) {

   828             error_str = PyString_InternFromString("error");

   829             if (error_str == NULL)

   830                 return NULL;

   831         }

   832         action_obj = error_str;

   833     }

   834     else if (!strcmp(action, "default")) {

   835         if (default_str == NULL) {

   836             default_str = PyString_InternFromString("default");

   837             if (default_str == NULL)

   838                 return NULL;

   839         }

   840         action_obj = default_str;

   841     }

   842     else {

   843         Py_FatalError("unknown action");

   844     }

   845 

   846     /* This assumes the line number is zero for now. */

   847     lineno = PyInt_FromLong(0);

   848     if (lineno == NULL)

   849         return NULL;

   850     result = PyTuple_Pack(5, action_obj, Py_None, category, Py_None, lineno);

   851     Py_DECREF(lineno);

   852     return result;

   853 }

   854 

   855 static PyObject *

   856 init_filters(void)

   857 {

   858     PyObject *filters = PyList_New(3);

   859     const char *bytes_action;

   860     if (filters == NULL)

   861         return NULL;

   862 

   863     PyList_SET_ITEM(filters, 0,

   864                     create_filter(PyExc_PendingDeprecationWarning, "ignore"));

   865     PyList_SET_ITEM(filters, 1, create_filter(PyExc_ImportWarning, "ignore"));

   866     if (Py_BytesWarningFlag > 1)

   867         bytes_action = "error";

   868     else if (Py_BytesWarningFlag)

   869         bytes_action = "default";

   870     else

   871         bytes_action = "ignore";

   872     PyList_SET_ITEM(filters, 2, create_filter(PyExc_BytesWarning,

   873                     bytes_action));

   874 

   875     if (PyList_GET_ITEM(filters, 0) == NULL ||

   876         PyList_GET_ITEM(filters, 1) == NULL ||

   877         PyList_GET_ITEM(filters, 2) == NULL) {

   878         Py_DECREF(filters);

   879         return NULL;

   880     }

   881 

   882     return filters;

   883 }

   884 

   885 

   886 PyMODINIT_FUNC

   887 _PyWarnings_Init(void)

   888 {

   889     PyObject *m, *default_action;

   890 

   891     m = Py_InitModule3(MODULE_NAME, warnings_functions, warnings__doc__);

   892     if (m == NULL)

   893         return;

   894 

   895     _filters = init_filters();

   896     if (_filters == NULL)

   897         return;

   898     Py_INCREF(_filters);

   899     if (PyModule_AddObject(m, "filters", _filters) < 0)

   900         return;

   901 

   902     _once_registry = PyDict_New();

   903     if (_once_registry == NULL)

   904         return;

   905     Py_INCREF(_once_registry);

   906     if (PyModule_AddObject(m, "once_registry", _once_registry) < 0)

   907         return;

   908 

   909     default_action = PyString_InternFromString("default");

   910     if (default_action == NULL)

   911         return;

   912     if (PyModule_AddObject(m, DEFAULT_ACTION_NAME, default_action) < 0)

   913         return;

   914 }