1 #include "Python.h"
2 #include "frameobject.h"
3 
4 #define MODULE_NAME "_warnings"
5 
6 PyDoc_STRVAR(warnings__doc__,
7 MODULE_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. */
12 static PyObject *_filters;  /* List */
13 static PyObject *_once_registry;  /* Dict */
14 static PyObject *_default_action; /* String */
15 
16 
17 static int
check_matched(PyObject * obj,PyObject * arg)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 *
get_warnings_attr(const char * attr)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 *
get_once_registry(void)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 static PyObject *
get_default_action(void)82 get_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. */
101 static const char *
get_filter(PyObject * category,PyObject * text,Py_ssize_t lineno,PyObject * module,PyObject ** item)102 get_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 
168 static int
already_warned(PyObject * registry,PyObject * key,int should_set)169 already_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. */
190 static PyObject *
normalize_module(PyObject * filename)191 normalize_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 
220 static int
update_registry(PyObject * registry,PyObject * text,PyObject * category,int add_zero)221 update_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 
242 static void
show_warning(PyObject * filename,int lineno,PyObject * text,PyObject * category,PyObject * sourceline)243 show_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 
288 static PyObject *
warn_explicit(PyObject * category,PyObject * message,PyObject * filename,int lineno,PyObject * module,PyObject * registry,PyObject * sourceline)289 warn_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 */
442 static int
setup_context(Py_ssize_t stack_level,PyObject ** filename,int * lineno,PyObject ** module,PyObject ** registry)443 setup_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) {
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         if (module_str && strcmp(module_str, "__main__") == 0) {
518             PyObject *argv = PySys_GetObject("argv");
519             if (argv != NULL && PyList_Size(argv) > 0) {
520                 int is_true;
521                 *filename = PyList_GetItem(argv, 0);
522                 Py_INCREF(*filename);
523                 /* If sys.argv[0] is false, then use '__main__'. */
524                 is_true = PyObject_IsTrue(*filename);
525                 if (is_true < 0) {
526                     Py_DECREF(*filename);
527                     goto handle_error;
528                 }
529                 else if (!is_true) {
530                     Py_DECREF(*filename);
531                     *filename = PyString_FromString("__main__");
532                     if (*filename == NULL)
533                         goto handle_error;
534                 }
535             }
536             else {
537                 /* embedded interpreters don't have sys.argv, see bug #839151 */
538                 *filename = PyString_FromString("__main__");
539                 if (*filename == NULL)
540                     goto handle_error;
541             }
542         }
543         if (*filename == NULL) {
544             *filename = *module;
545             Py_INCREF(*filename);
546         }
547     }
548 
549     return 1;
550 
551  handle_error:
552     /* filename not XDECREF'ed here as there is no way to jump here with a
553        dangling reference. */
554     Py_XDECREF(*registry);
555     Py_XDECREF(*module);
556     return 0;
557 }
558 
559 static PyObject *
get_category(PyObject * message,PyObject * category)560 get_category(PyObject *message, PyObject *category)
561 {
562     int rc;
563 
564     /* Get category. */
565     rc = PyObject_IsInstance(message, PyExc_Warning);
566     if (rc == -1)
567         return NULL;
568 
569     if (rc == 1)
570         category = (PyObject*)message->ob_type;
571     else if (category == NULL)
572         category = PyExc_UserWarning;
573 
574     /* Validate category. */
575     rc = PyObject_IsSubclass(category, PyExc_Warning);
576     if (rc == -1)
577         return NULL;
578     if (rc == 0) {
579         PyErr_SetString(PyExc_ValueError,
580                         "category is not a subclass of Warning");
581         return NULL;
582     }
583 
584     return category;
585 }
586 
587 static PyObject *
do_warn(PyObject * message,PyObject * category,Py_ssize_t stack_level)588 do_warn(PyObject *message, PyObject *category, Py_ssize_t stack_level)
589 {
590     PyObject *filename, *module, *registry, *res;
591     int lineno;
592 
593     if (!setup_context(stack_level, &filename, &lineno, &module, &registry))
594         return NULL;
595 
596     res = warn_explicit(category, message, filename, lineno, module, registry,
597                         NULL);
598     Py_DECREF(filename);
599     Py_DECREF(registry);
600     Py_DECREF(module);
601     return res;
602 }
603 
604 static PyObject *
warnings_warn(PyObject * self,PyObject * args,PyObject * kwds)605 warnings_warn(PyObject *self, PyObject *args, PyObject *kwds)
606 {
607     static char *kw_list[] = { "message", "category", "stacklevel", 0 };
608     PyObject *message, *category = NULL;
609     Py_ssize_t stack_level = 1;
610 
611     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|On:warn", kw_list,
612                                      &message, &category, &stack_level))
613         return NULL;
614 
615     category = get_category(message, category);
616     if (category == NULL)
617         return NULL;
618     return do_warn(message, category, stack_level);
619 }
620 
621 static PyObject *
warnings_warn_explicit(PyObject * self,PyObject * args,PyObject * kwds)622 warnings_warn_explicit(PyObject *self, PyObject *args, PyObject *kwds)
623 {
624     static char *kwd_list[] = {"message", "category", "filename", "lineno",
625                                 "module", "registry", "module_globals", 0};
626     PyObject *message;
627     PyObject *category;
628     PyObject *filename;
629     int lineno;
630     PyObject *module = NULL;
631     PyObject *registry = NULL;
632     PyObject *module_globals = NULL;
633 
634     if (!PyArg_ParseTupleAndKeywords(args, kwds, "OOOi|OOO:warn_explicit",
635                 kwd_list, &message, &category, &filename, &lineno, &module,
636                 &registry, &module_globals))
637         return NULL;
638 
639     if (module_globals) {
640         static PyObject *get_source_name = NULL;
641         static PyObject *splitlines_name = NULL;
642         PyObject *loader;
643         PyObject *module_name;
644         PyObject *source;
645         PyObject *source_list;
646         PyObject *source_line;
647         PyObject *returned;
648 
649         if (get_source_name == NULL) {
650             get_source_name = PyString_InternFromString("get_source");
651             if (!get_source_name)
652                 return NULL;
653         }
654         if (splitlines_name == NULL) {
655             splitlines_name = PyString_InternFromString("splitlines");
656             if (!splitlines_name)
657                 return NULL;
658         }
659 
660         /* Check/get the requisite pieces needed for the loader. */
661         loader = PyDict_GetItemString(module_globals, "__loader__");
662         module_name = PyDict_GetItemString(module_globals, "__name__");
663 
664         if (loader == NULL || module_name == NULL)
665             goto standard_call;
666 
667         /* Make sure the loader implements the optional get_source() method. */
668         if (!PyObject_HasAttrString(loader, "get_source"))
669                 goto standard_call;
670         /* Call get_source() to get the source code. */
671         source = PyObject_CallMethodObjArgs(loader, get_source_name,
672                                                 module_name, NULL);
673         if (!source)
674             return NULL;
675         else if (source == Py_None) {
676             Py_DECREF(Py_None);
677             goto standard_call;
678         }
679 
680         /* Split the source into lines. */
681         source_list = PyObject_CallMethodObjArgs(source, splitlines_name,
682                                                     NULL);
683         Py_DECREF(source);
684         if (!source_list)
685             return NULL;
686 
687         /* Get the source line. */
688         source_line = PyList_GetItem(source_list, lineno-1);
689         if (!source_line) {
690             Py_DECREF(source_list);
691             return NULL;
692         }
693 
694         /* Handle the warning. */
695         returned = warn_explicit(category, message, filename, lineno, module,
696                             registry, source_line);
697         Py_DECREF(source_list);
698         return returned;
699     }
700 
701  standard_call:
702     return warn_explicit(category, message, filename, lineno, module,
703                                 registry, NULL);
704 }
705 
706 
707 /* Function to issue a warning message; may raise an exception. */
708 int
PyErr_WarnEx(PyObject * category,const char * text,Py_ssize_t stack_level)709 PyErr_WarnEx(PyObject *category, const char *text, Py_ssize_t stack_level)
710 {
711     PyObject *res;
712     PyObject *message = PyString_FromString(text);
713     if (message == NULL)
714         return -1;
715 
716     if (category == NULL)
717         category = PyExc_RuntimeWarning;
718 
719     res = do_warn(message, category, stack_level);
720     Py_DECREF(message);
721     if (res == NULL)
722         return -1;
723     Py_DECREF(res);
724 
725     return 0;
726 }
727 
728 /* PyErr_Warn is only for backwards compatibility and will be removed.
729    Use PyErr_WarnEx instead. */
730 
731 #undef PyErr_Warn
732 
733 PyAPI_FUNC(int)
PyErr_Warn(PyObject * category,char * text)734 PyErr_Warn(PyObject *category, char *text)
735 {
736     return PyErr_WarnEx(category, text, 1);
737 }
738 
739 /* Warning with explicit origin */
740 int
PyErr_WarnExplicit(PyObject * category,const char * text,const char * filename_str,int lineno,const char * module_str,PyObject * registry)741 PyErr_WarnExplicit(PyObject *category, const char *text,
742                    const char *filename_str, int lineno,
743                    const char *module_str, PyObject *registry)
744 {
745     PyObject *res;
746     PyObject *message = PyString_FromString(text);
747     PyObject *filename = PyString_FromString(filename_str);
748     PyObject *module = NULL;
749     int ret = -1;
750 
751     if (message == NULL || filename == NULL)
752         goto exit;
753     if (module_str != NULL) {
754         module = PyString_FromString(module_str);
755             if (module == NULL)
756                 goto exit;
757     }
758 
759     if (category == NULL)
760         category = PyExc_RuntimeWarning;
761     res = warn_explicit(category, message, filename, lineno, module, registry,
762                         NULL);
763     if (res == NULL)
764         goto exit;
765     Py_DECREF(res);
766     ret = 0;
767 
768  exit:
769     Py_XDECREF(message);
770     Py_XDECREF(module);
771     Py_XDECREF(filename);
772     return ret;
773 }
774 
775 
776 PyDoc_STRVAR(warn_doc,
777 "Issue a warning, or maybe ignore it or raise an exception.");
778 
779 PyDoc_STRVAR(warn_explicit_doc,
780 "Low-level inferface to warnings functionality.");
781 
782 static PyMethodDef warnings_functions[] = {
783     {"warn", (PyCFunction)warnings_warn, METH_VARARGS | METH_KEYWORDS,
784         warn_doc},
785     {"warn_explicit", (PyCFunction)warnings_warn_explicit,
786         METH_VARARGS | METH_KEYWORDS, warn_explicit_doc},
787     /* XXX(brett.cannon): add showwarning? */
788     /* XXX(brett.cannon): Reasonable to add formatwarning? */
789     {NULL, NULL}	        /* sentinel */
790 };
791 
792 
793 static PyObject *
create_filter(PyObject * category,const char * action)794 create_filter(PyObject *category, const char *action)
795 {
796     static PyObject *ignore_str = NULL;
797     static PyObject *error_str = NULL;
798     static PyObject *default_str = NULL;
799     PyObject *action_obj = NULL;
800     PyObject *lineno, *result;
801 
802     if (!strcmp(action, "ignore")) {
803         if (ignore_str == NULL) {
804             ignore_str = PyString_InternFromString("ignore");
805             if (ignore_str == NULL)
806                 return NULL;
807         }
808         action_obj = ignore_str;
809     }
810     else if (!strcmp(action, "error")) {
811         if (error_str == NULL) {
812             error_str = PyString_InternFromString("error");
813             if (error_str == NULL)
814                 return NULL;
815         }
816         action_obj = error_str;
817     }
818     else if (!strcmp(action, "default")) {
819         if (default_str == NULL) {
820             default_str = PyString_InternFromString("default");
821             if (default_str == NULL)
822                 return NULL;
823         }
824         action_obj = default_str;
825     }
826     else {
827         Py_FatalError("unknown action");
828     }
829 
830     /* This assumes the line number is zero for now. */
831     lineno = PyInt_FromLong(0);
832     if (lineno == NULL)
833         return NULL;
834     result = PyTuple_Pack(5, action_obj, Py_None, category, Py_None, lineno);
835     Py_DECREF(lineno);
836     return result;
837 }
838 
839 static PyObject *
init_filters(void)840 init_filters(void)
841 {
842     /* Don't silence DeprecationWarning if -3 or -Q were used. */
843     PyObject *filters = PyList_New(Py_Py3kWarningFlag ||
844                                     Py_DivisionWarningFlag ? 3 : 4);
845     unsigned int pos = 0;  /* Post-incremented in each use. */
846     unsigned int x;
847     const char *bytes_action;
848 
849     if (filters == NULL)
850         return NULL;
851 
852     /* If guard changes, make sure to update 'filters' initialization above. */
853     if (!Py_Py3kWarningFlag && !Py_DivisionWarningFlag) {
854         PyList_SET_ITEM(filters, pos++,
855                         create_filter(PyExc_DeprecationWarning, "ignore"));
856     }
857     PyList_SET_ITEM(filters, pos++,
858                     create_filter(PyExc_PendingDeprecationWarning, "ignore"));
859     PyList_SET_ITEM(filters, pos++,
860                     create_filter(PyExc_ImportWarning, "ignore"));
861     if (Py_BytesWarningFlag > 1)
862         bytes_action = "error";
863     else if (Py_BytesWarningFlag)
864         bytes_action = "default";
865     else
866         bytes_action = "ignore";
867     PyList_SET_ITEM(filters, pos++, create_filter(PyExc_BytesWarning,
868                     bytes_action));
869 
870     for (x = 0; x < pos; x += 1) {
871         if (PyList_GET_ITEM(filters, x) == NULL) {
872             Py_DECREF(filters);
873             return NULL;
874         }
875     }
876 
877     return filters;
878 }
879 
880 
881 PyMODINIT_FUNC
_PyWarnings_Init(void)882 _PyWarnings_Init(void)
883 {
884     PyObject *m;
885 
886     m = Py_InitModule3(MODULE_NAME, warnings_functions, warnings__doc__);
887     if (m == NULL)
888         return;
889 
890     _filters = init_filters();
891     if (_filters == NULL)
892         return;
893     Py_INCREF(_filters);
894     if (PyModule_AddObject(m, "filters", _filters) < 0)
895         return;
896 
897     _once_registry = PyDict_New();
898     if (_once_registry == NULL)
899         return;
900     Py_INCREF(_once_registry);
901     if (PyModule_AddObject(m, "once_registry", _once_registry) < 0)
902         return;
903 
904     _default_action = PyString_FromString("default");
905     if (_default_action == NULL)
906         return;
907     if (PyModule_AddObject(m, "default_action", _default_action) < 0)
908         return;
909 }
910