# error "this header requires Py_BUILD_CORE define"
#endif
+PyAPI_FUNC(int) _PySys_GetOptionalAttr(PyObject *, PyObject **);
+PyAPI_FUNC(int) _PySys_GetOptionalAttrString(const char *, PyObject **);
+PyAPI_FUNC(PyObject *) _PySys_GetRequiredAttr(PyObject *);
+PyAPI_FUNC(PyObject *) _PySys_GetRequiredAttrString(const char *);
+
PyAPI_FUNC(int) _PySys_Audit(
PyThreadState *tstate,
const char *event,
sys.stdout = savestdout
fp.close()
+ def test_input_gh130163(self):
+ class X(io.StringIO):
+ def __getattribute__(self, name):
+ nonlocal patch
+ if patch:
+ patch = False
+ sys.stdout = X()
+ sys.stderr = X()
+ sys.stdin = X('input\n')
+ support.gc_collect()
+ return io.StringIO.__getattribute__(self, name)
+
+ with (support.swap_attr(sys, 'stdout', None),
+ support.swap_attr(sys, 'stderr', None),
+ support.swap_attr(sys, 'stdin', None)):
+ patch = False
+ # the only references:
+ sys.stdout = X()
+ sys.stderr = X()
+ sys.stdin = X('input\n')
+ patch = True
+ input() # should not crash
+
# test_int(): see test_int.py for tests of built-in function int().
def test_repr(self):
raise RuntimeError
self.assertRaises(RuntimeError, print, 1, file=noflush(), flush=True)
+ def test_gh130163(self):
+ class X:
+ def __str__(self):
+ sys.stdout = StringIO()
+ support.gc_collect()
+ return 'foo'
+
+ with support.swap_attr(sys, 'stdout', None):
+ sys.stdout = StringIO() # the only reference
+ print(X()) # should not crash
+
class TestPy2MigrationHint(unittest.TestCase):
"""Test that correct hint is produced analogous to Python3 syntax,
import builtins
import codecs
import gc
+import io
import locale
import operator
import os
code = compile("42", "<string>", "single")
self.assertRaises(ValueError, eval, code)
+ def test_gh130163(self):
+ class X:
+ def __repr__(self):
+ sys.stdout = io.StringIO()
+ support.gc_collect()
+ return 'foo'
+
+ with support.swap_attr(sys, 'stdout', None):
+ sys.stdout = io.StringIO() # the only reference
+ sys.displayhook(X()) # should not crash
+
+
class ActiveExceptionTests(unittest.TestCase):
def test_exc_info_no_exception(self):
self.assertEqual(sys.exc_info(), (None, None, None))
--- /dev/null
+Fix possible crashes related to concurrent
+change and use of the :mod:`sys` module attributes.
#include "Python.h"
#include "pycore_long.h" // _PyLong_GetZero()
#include "pycore_structseq.h" // _PyStructSequence_NewType()
+#include "pycore_sysmodule.h" // _PySys_GetOptionalAttrString()
#ifdef __hpux
#define STRICT_SYSV_CURSES
if (fd == -1) {
PyObject* sys_stdout;
- sys_stdout = PySys_GetObject("stdout");
+ if (_PySys_GetOptionalAttrString("stdout", &sys_stdout) < 0) {
+ return NULL;
+ }
if (sys_stdout == NULL || sys_stdout == Py_None) {
PyErr_SetString(
PyCursesError,
"lost sys.stdout");
+ Py_XDECREF(sys_stdout);
return NULL;
}
fd = PyObject_AsFileDescriptor(sys_stdout);
-
+ Py_DECREF(sys_stdout);
if (fd == -1) {
return NULL;
}
#include "pycore_moduleobject.h" // _PyModule_GetState()
#include "pycore_runtime.h" // _Py_ID()
#include "pycore_pystate.h" // _PyThreadState_GET()
+#include "pycore_sysmodule.h" // _PySys_GetRequiredAttr()
#include "structmember.h" // PyMemberDef
#include <stdlib.h> // strtol()
assert(module_name == NULL);
/* Fallback on walking sys.modules */
- PyThreadState *tstate = _PyThreadState_GET();
- modules = _PySys_GetAttr(tstate, &_Py_ID(modules));
+ modules = _PySys_GetRequiredAttr(&_Py_ID(modules));
if (modules == NULL) {
- PyErr_SetString(PyExc_RuntimeError, "unable to get sys.modules");
return NULL;
}
if (PyDict_CheckExact(modules)) {
i = 0;
while (PyDict_Next(modules, &i, &module_name, &module)) {
if (_checkmodule(module_name, module, global, dotted_path) == 0) {
+ Py_DECREF(modules);
return Py_NewRef(module_name);
}
if (PyErr_Occurred()) {
+ Py_DECREF(modules);
return NULL;
}
}
else {
PyObject *iterator = PyObject_GetIter(modules);
if (iterator == NULL) {
+ Py_DECREF(modules);
return NULL;
}
while ((module_name = PyIter_Next(iterator))) {
if (module == NULL) {
Py_DECREF(module_name);
Py_DECREF(iterator);
+ Py_DECREF(modules);
return NULL;
}
if (_checkmodule(module_name, module, global, dotted_path) == 0) {
Py_DECREF(module);
Py_DECREF(iterator);
+ Py_DECREF(modules);
return module_name;
}
Py_DECREF(module);
Py_DECREF(module_name);
if (PyErr_Occurred()) {
Py_DECREF(iterator);
+ Py_DECREF(modules);
return NULL;
}
}
Py_DECREF(iterator);
}
+ Py_DECREF(modules);
/* If no module is found, use __main__. */
module_name = &_Py_ID(__main__);
#include "pycore_moduleobject.h" // _PyModule_GetState()
#include "pycore_pylifecycle.h"
#include "pycore_pystate.h" // _PyThreadState_SetCurrent()
+#include "pycore_sysmodule.h" // _PySys_GetOptionalAttr()
+
#include <stddef.h> // offsetof()
#include "structmember.h" // PyMemberDef
PyObject *exc_tb = PyStructSequence_GET_ITEM(args, 2);
PyObject *thread = PyStructSequence_GET_ITEM(args, 3);
- PyThreadState *tstate = _PyThreadState_GET();
- PyObject *file = _PySys_GetAttr(tstate, &_Py_ID(stderr));
+ PyObject *file;
+ if (_PySys_GetOptionalAttr( &_Py_ID(stderr), &file) < 0) {
+ return NULL;
+ }
if (file == NULL || file == Py_None) {
+ Py_XDECREF(file);
if (thread == Py_None) {
/* do nothing if sys.stderr is None and thread is None */
Py_RETURN_NONE;
Py_RETURN_NONE;
}
}
- else {
- Py_INCREF(file);
- }
int res = thread_excepthook_file(file, exc_type, exc_value, exc_tb,
thread);
#endif
#include "pycore_long.h"
+#include "pycore_sysmodule.h" // _PySys_GetOptionalAttrString()
#ifdef MS_WINDOWS
#include <windows.h>
/* Check expected location for an installed Python first */
tcl_library_path = PyUnicode_FromString("\\tcl\\tcl" TCL_VERSION);
if (tcl_library_path == NULL) {
+ Py_DECREF(prefix);
return NULL;
}
tcl_library_path = PyUnicode_Concat(prefix, tcl_library_path);
+ Py_DECREF(prefix);
if (tcl_library_path == NULL) {
return NULL;
}
uexe = PyUnicode_FromWideChar(Py_GetProgramName(), -1);
if (uexe) {
cexe = PyUnicode_EncodeFSDefault(uexe);
+ Py_DECREF(uexe);
if (cexe) {
#ifdef MS_WINDOWS
int set_var = 0;
if (!ret && GetLastError() == ERROR_ENVVAR_NOT_FOUND) {
str_path = _get_tcl_lib_path();
if (str_path == NULL && PyErr_Occurred()) {
+ Py_DECREF(cexe);
Py_DECREF(m);
return NULL;
}
if (str_path != NULL) {
wcs_path = PyUnicode_AsWideCharString(str_path, NULL);
if (wcs_path == NULL) {
+ Py_DECREF(cexe);
Py_DECREF(m);
return NULL;
}
#endif /* MS_WINDOWS */
}
Py_XDECREF(cexe);
- Py_DECREF(uexe);
}
if (PyErr_Occurred()) {
#include "pycore_pyerrors.h" // _Py_DumpExtensionModules
#include "pycore_pystate.h" // _PyThreadState_GET()
#include "pycore_signal.h" // Py_NSIG
+#include "pycore_sysmodule.h" // _PySys_GetRequiredAttr()
#include "pycore_traceback.h" // _Py_DumpTracebackThreads
#include <object.h>
PyObject *file = *file_ptr;
if (file == NULL || file == Py_None) {
- PyThreadState *tstate = _PyThreadState_GET();
- file = _PySys_GetAttr(tstate, &_Py_ID(stderr));
+ file = _PySys_GetRequiredAttr(&_Py_ID(stderr));
if (file == NULL) {
- PyErr_SetString(PyExc_RuntimeError, "unable to get sys.stderr");
return -1;
}
if (file == Py_None) {
PyErr_SetString(PyExc_RuntimeError, "sys.stderr is None");
+ Py_DECREF(file);
return -1;
}
}
*file_ptr = NULL;
return fd;
}
+ else {
+ Py_INCREF(file);
+ }
result = PyObject_CallMethodNoArgs(file, &_Py_ID(fileno));
- if (result == NULL)
+ if (result == NULL) {
+ Py_DECREF(file);
return -1;
+ }
fd = -1;
if (PyLong_Check(result)) {
if (fd == -1) {
PyErr_SetString(PyExc_RuntimeError,
"file.fileno() is not a valid file descriptor");
+ Py_DECREF(file);
return -1;
}
return NULL;
tstate = get_thread_state();
- if (tstate == NULL)
+ if (tstate == NULL) {
+ Py_XDECREF(file);
return NULL;
+ }
if (all_threads) {
errmsg = _Py_DumpTracebackThreads(fd, NULL, tstate);
if (errmsg != NULL) {
PyErr_SetString(PyExc_RuntimeError, errmsg);
+ Py_XDECREF(file);
return NULL;
}
}
else {
_Py_DumpTraceback(fd, tstate);
}
+ Py_XDECREF(file);
if (PyErr_CheckSignals())
return NULL;
return NULL;
tstate = get_thread_state();
- if (tstate == NULL)
+ if (tstate == NULL) {
+ Py_XDECREF(file);
return NULL;
+ }
- Py_XINCREF(file);
Py_XSETREF(fatal_error.file, file);
fatal_error.fd = fd;
fatal_error.all_threads = all_threads;
if (!thread.running) {
thread.running = PyThread_allocate_lock();
if (!thread.running) {
+ Py_XDECREF(file);
return PyErr_NoMemory();
}
}
if (!thread.cancel_event) {
thread.cancel_event = PyThread_allocate_lock();
if (!thread.cancel_event || !thread.running) {
+ Py_XDECREF(file);
return PyErr_NoMemory();
}
/* format the timeout */
header = format_timeout(timeout_us);
if (header == NULL) {
+ Py_XDECREF(file);
return PyErr_NoMemory();
}
header_len = strlen(header);
/* Cancel previous thread, if running */
cancel_dump_traceback_later();
- Py_XINCREF(file);
Py_XSETREF(thread.file, file);
thread.fd = fd;
/* the downcast is safe: we check that 0 < timeout_us < PY_TIMEOUT_MAX */
if (user_signals == NULL) {
user_signals = PyMem_Calloc(Py_NSIG, sizeof(user_signal_t));
- if (user_signals == NULL)
+ if (user_signals == NULL) {
+ Py_XDECREF(file);
return PyErr_NoMemory();
+ }
}
user = &user_signals[signum];
if (!user->enabled) {
#ifdef FAULTHANDLER_USE_ALT_STACK
if (faulthandler_allocate_stack() < 0) {
+ Py_XDECREF(file);
return NULL;
}
#endif
err = faulthandler_register(signum, chain, &previous);
if (err) {
PyErr_SetFromErrno(PyExc_OSError);
+ Py_XDECREF(file);
return NULL;
}
user->previous = previous;
}
- Py_XINCREF(file);
Py_XSETREF(user->file, file);
user->fd = fd;
user->all_threads = all_threads;
/* syslog module */
+#ifndef Py_BUILD_CORE_BUILTIN
+# define Py_BUILD_CORE_MODULE 1
+#endif
+
#include "Python.h"
#include "osdefs.h" // SEP
+#include "pycore_sysmodule.h" // _PySys_GetOptionalAttrString()
#include <syslog.h>
Py_ssize_t argv_len, scriptlen;
PyObject *scriptobj;
Py_ssize_t slash;
- PyObject *argv = PySys_GetObject("argv");
+ PyObject *argv;
- if (argv == NULL) {
- return(NULL);
+ if (_PySys_GetOptionalAttrString("argv", &argv) <= 0) {
+ return NULL;
}
argv_len = PyList_Size(argv);
if (argv_len == -1) {
PyErr_Clear();
- return(NULL);
+ Py_DECREF(argv);
+ return NULL;
}
if (argv_len == 0) {
- return(NULL);
+ Py_DECREF(argv);
+ return NULL;
}
scriptobj = PyList_GetItem(argv, 0);
+ Py_XINCREF(scriptobj);
+ Py_DECREF(argv);
if (scriptobj == NULL) {
PyErr_Clear();
return NULL;
}
if (!PyUnicode_Check(scriptobj)) {
- return(NULL);
+ Py_DECREF(scriptobj);
+ return NULL;
}
scriptlen = PyUnicode_GET_LENGTH(scriptobj);
if (scriptlen == 0) {
- return(NULL);
+ Py_DECREF(scriptobj);
+ return NULL;
}
slash = PyUnicode_FindChar(scriptobj, SEP, 0, scriptlen, -1);
if (slash == -2) {
PyErr_Clear();
+ Py_DECREF(scriptobj);
return NULL;
}
if (slash != -1) {
- return PyUnicode_Substring(scriptobj, slash + 1, scriptlen);
- } else {
- Py_INCREF(scriptobj);
- return(scriptobj);
+ Py_SETREF(scriptobj, PyUnicode_Substring(scriptobj, slash + 1, scriptlen));
}
+ return scriptobj;
}
else {
/* get sys.argv[0] or NULL if we can't for some reason */
ident = syslog_get_argv();
+ if (ident == NULL && PyErr_Occurred()) {
+ return NULL;
+ }
}
/* At this point, ident should be INCREF()ed. openlog(3) does not
#include "pycore_pyerrors.h"
#include "pycore_pystate.h" // _PyThreadState_GET()
#include "pycore_frame.h"
+#include "pycore_sysmodule.h" // _PySys_GetOptionalAttr()
+
#include "clinic/_warnings.c.h"
#define MODULE_NAME "_warnings"
show_warning(PyThreadState *tstate, PyObject *filename, int lineno,
PyObject *text, PyObject *category, PyObject *sourceline)
{
- PyObject *f_stderr;
+ PyObject *f_stderr = NULL;
PyObject *name;
char lineno_str[128];
goto error;
}
- f_stderr = _PySys_GetAttr(tstate, &_Py_ID(stderr));
- if (f_stderr == NULL) {
+ if (_PySys_GetOptionalAttr(&_Py_ID(stderr), &f_stderr) <= 0) {
fprintf(stderr, "lost sys.stderr\n");
goto error;
}
}
error:
+ Py_XDECREF(f_stderr);
Py_XDECREF(name);
PyErr_Clear();
}
#include "pycore_object.h" // _Py_AddToAllObjects()
#include "pycore_pyerrors.h" // _PyErr_NoMemory()
#include "pycore_pystate.h" // _PyThreadState_GET()
+#include "pycore_sysmodule.h" // _PySys_GetRequiredAttr()
#include "pycore_tuple.h" // _PyTuple_FromArray()
#include "pycore_ceval.h" // _PyEval_Vector()
static PyObject *
builtin_breakpoint(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *keywords)
{
- PyObject *hook = PySys_GetObject("breakpointhook");
-
+ PyObject *hook = _PySys_GetRequiredAttrString("breakpointhook");
if (hook == NULL) {
- PyErr_SetString(PyExc_RuntimeError, "lost sys.breakpointhook");
return NULL;
}
if (PySys_Audit("builtins.breakpoint", "O", hook) < 0) {
+ Py_DECREF(hook);
return NULL;
}
- Py_INCREF(hook);
PyObject *retval = PyObject_Vectorcall(hook, args, nargs, keywords);
Py_DECREF(hook);
return retval;
int i, err;
if (file == Py_None) {
- PyThreadState *tstate = _PyThreadState_GET();
- file = _PySys_GetAttr(tstate, &_Py_ID(stdout));
+ file = _PySys_GetRequiredAttr(&_Py_ID(stdout));
if (file == NULL) {
- PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout");
return NULL;
}
/* sys.stdout may be None when FILE* stdout isn't connected */
if (file == Py_None) {
+ Py_DECREF(file);
Py_RETURN_NONE;
}
}
+ else {
+ Py_INCREF(file);
+ }
if (sep == Py_None) {
sep = NULL;
PyErr_Format(PyExc_TypeError,
"sep must be None or a string, not %.200s",
Py_TYPE(sep)->tp_name);
+ Py_DECREF(file);
return NULL;
}
if (end == Py_None) {
PyErr_Format(PyExc_TypeError,
"end must be None or a string, not %.200s",
Py_TYPE(end)->tp_name);
+ Py_DECREF(file);
return NULL;
}
err = PyFile_WriteObject(sep, file, Py_PRINT_RAW);
}
if (err) {
+ Py_DECREF(file);
return NULL;
}
}
err = PyFile_WriteObject(PyTuple_GET_ITEM(args, i), file, Py_PRINT_RAW);
if (err) {
+ Py_DECREF(file);
return NULL;
}
}
err = PyFile_WriteObject(end, file, Py_PRINT_RAW);
}
if (err) {
+ Py_DECREF(file);
return NULL;
}
if (flush) {
PyObject *tmp = PyObject_CallMethodNoArgs(file, &_Py_ID(flush));
if (tmp == NULL) {
+ Py_DECREF(file);
return NULL;
}
Py_DECREF(tmp);
}
+ Py_DECREF(file);
Py_RETURN_NONE;
}
builtin_input_impl(PyObject *module, PyObject *prompt)
/*[clinic end generated code: output=83db5a191e7a0d60 input=159c46d4ae40977e]*/
{
- PyThreadState *tstate = _PyThreadState_GET();
- PyObject *fin = _PySys_GetAttr(
- tstate, &_Py_ID(stdin));
- PyObject *fout = _PySys_GetAttr(
- tstate, &_Py_ID(stdout));
- PyObject *ferr = _PySys_GetAttr(
- tstate, &_Py_ID(stderr));
+ PyObject *fin = NULL;
+ PyObject *fout = NULL;
+ PyObject *ferr = NULL;
PyObject *tmp;
long fd;
int tty;
/* Check that stdin/out/err are intact */
- if (fin == NULL || fin == Py_None) {
- PyErr_SetString(PyExc_RuntimeError,
- "input(): lost sys.stdin");
- return NULL;
+ fin = _PySys_GetRequiredAttr(&_Py_ID(stdin));
+ if (fin == NULL) {
+ goto error;
}
- if (fout == NULL || fout == Py_None) {
- PyErr_SetString(PyExc_RuntimeError,
- "input(): lost sys.stdout");
- return NULL;
+ if (fin == Py_None) {
+ PyErr_SetString(PyExc_RuntimeError, "lost sys.stdin");
+ goto error;
}
- if (ferr == NULL || ferr == Py_None) {
- PyErr_SetString(PyExc_RuntimeError,
- "input(): lost sys.stderr");
- return NULL;
+ fout = _PySys_GetRequiredAttr(&_Py_ID(stdout));
+ if (fout == NULL) {
+ goto error;
+ }
+ if (fout == Py_None) {
+ PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout");
+ goto error;
+ }
+ ferr = _PySys_GetRequiredAttr(&_Py_ID(stderr));
+ if (ferr == NULL) {
+ goto error;
+ }
+ if (ferr == Py_None) {
+ PyErr_SetString(PyExc_RuntimeError, "lost sys.stderr");
+ goto error;
}
if (PySys_Audit("builtins.input", "O", prompt ? prompt : Py_None) < 0) {
- return NULL;
+ goto error;
}
/* First of all, flush stderr */
else {
fd = PyLong_AsLong(tmp);
Py_DECREF(tmp);
- if (fd < 0 && PyErr_Occurred())
- return NULL;
+ if (fd < 0 && PyErr_Occurred()) {
+ goto error;
+ }
tty = fd == fileno(stdin) && isatty(fd);
}
if (tty) {
fd = PyLong_AsLong(tmp);
Py_DECREF(tmp);
if (fd < 0 && PyErr_Occurred())
- return NULL;
+ goto error;
tty = fd == fileno(stdout) && isatty(fd);
}
}
if (result != NULL) {
if (PySys_Audit("builtins.input/result", "O", result) < 0) {
- return NULL;
+ goto error;
}
}
+ Py_DECREF(fin);
+ Py_DECREF(fout);
+ Py_DECREF(ferr);
return result;
_readline_errors:
Py_XDECREF(stdout_errors);
Py_XDECREF(po);
if (tty)
- return NULL;
+ goto error;
PyErr_Clear();
}
/* Fallback if we're not interactive */
if (prompt != NULL) {
if (PyFile_WriteObject(prompt, fout, Py_PRINT_RAW) != 0)
- return NULL;
+ goto error;
}
tmp = PyObject_CallMethodNoArgs(fout, &_Py_ID(flush));
if (tmp == NULL)
PyErr_Clear();
else
Py_DECREF(tmp);
- return PyFile_GetLine(fin, -1);
+
+ tmp = PyFile_GetLine(fin, -1);
+ Py_DECREF(fin);
+ Py_DECREF(fout);
+ Py_DECREF(ferr);
+ return tmp;
+
+error:
+ Py_XDECREF(fin);
+ Py_XDECREF(fout);
+ Py_XDECREF(ferr);
+ return NULL;
}
PyObject *exc_value, PyObject *exc_tb, PyObject *err_msg,
PyObject *obj)
{
- PyObject *file = _PySys_GetAttr(tstate, &_Py_ID(stderr));
+ PyObject *file;
+ if (_PySys_GetOptionalAttr(&_Py_ID(stderr), &file) < 0) {
+ return -1;
+ }
if (file == NULL || file == Py_None) {
+ Py_XDECREF(file);
return 0;
}
- /* Hold a strong reference to ensure that sys.stderr doesn't go away
- while we use it */
- Py_INCREF(file);
int res = write_unraisable_exc_file(tstate, exc_type, exc_value, exc_tb,
err_msg, obj, file);
Py_DECREF(file);
goto error;
}
- PyObject *hook = _PySys_GetAttr(tstate, &_Py_ID(unraisablehook));
+ PyObject *hook;
+ if (_PySys_GetOptionalAttr(&_Py_ID(unraisablehook), &hook) < 0) {
+ Py_DECREF(hook_args);
+ err_msg_str = NULL;
+ obj = NULL;
+ goto error;
+ }
if (hook == NULL) {
Py_DECREF(hook_args);
goto default_hook;
}
if (_PySys_Audit(tstate, "sys.unraisablehook", "OO", hook, hook_args) < 0) {
+ Py_DECREF(hook);
Py_DECREF(hook_args);
err_msg_str = "Exception ignored in audit hook";
obj = NULL;
}
if (hook == Py_None) {
+ Py_DECREF(hook);
Py_DECREF(hook_args);
goto default_hook;
}
PyObject *res = PyObject_CallOneArg(hook, hook_args);
+ Py_DECREF(hook);
Py_DECREF(hook_args);
if (res != NULL) {
Py_DECREF(res);
PyImport_GetImporter(PyObject *path)
{
PyThreadState *tstate = _PyThreadState_GET();
- PyObject *path_importer_cache = PySys_GetObject("path_importer_cache");
+ PyObject *path_importer_cache = _PySys_GetRequiredAttrString("path_importer_cache");
if (path_importer_cache == NULL) {
- PyErr_SetString(PyExc_RuntimeError, "lost sys.path_importer_cache");
return NULL;
}
- Py_INCREF(path_importer_cache);
- PyObject *path_hooks = PySys_GetObject("path_hooks");
+ PyObject *path_hooks = _PySys_GetRequiredAttrString("path_hooks");
if (path_hooks == NULL) {
- PyErr_SetString(PyExc_RuntimeError, "lost sys.path_hooks");
Py_DECREF(path_importer_cache);
return NULL;
}
- Py_INCREF(path_hooks);
PyObject *importer = get_path_importer(tstate, path_importer_cache, path_hooks, path);
Py_DECREF(path_hooks);
Py_DECREF(path_importer_cache);
_PyTime_t t1 = 0, accumulated_copy = accumulated;
- PyObject *sys_path = PySys_GetObject("path");
- PyObject *sys_meta_path = PySys_GetObject("meta_path");
- PyObject *sys_path_hooks = PySys_GetObject("path_hooks");
+ PyObject *sys_path, *sys_meta_path, *sys_path_hooks;
+ if (_PySys_GetOptionalAttrString("path", &sys_path) < 0) {
+ return NULL;
+ }
+ if (_PySys_GetOptionalAttrString("meta_path", &sys_meta_path) < 0) {
+ Py_XDECREF(sys_path);
+ return NULL;
+ }
+ if (_PySys_GetOptionalAttrString("path_hooks", &sys_path_hooks) < 0) {
+ Py_XDECREF(sys_meta_path);
+ Py_XDECREF(sys_path);
+ return NULL;
+ }
if (_PySys_Audit(tstate, "import", "OOOOO",
abs_name, Py_None, sys_path ? sys_path : Py_None,
sys_meta_path ? sys_meta_path : Py_None,
sys_path_hooks ? sys_path_hooks : Py_None) < 0) {
+ Py_XDECREF(sys_path_hooks);
+ Py_XDECREF(sys_meta_path);
+ Py_XDECREF(sys_path);
return NULL;
}
+ Py_XDECREF(sys_path_hooks);
+ Py_XDECREF(sys_meta_path);
+ Py_XDECREF(sys_path);
/* XOptions is initialized after first some imports.
static int
init_zipimport(PyThreadState *tstate, int verbose)
{
- PyObject *path_hooks = PySys_GetObject("path_hooks");
+ PyObject *path_hooks = _PySys_GetRequiredAttrString("path_hooks");
if (path_hooks == NULL) {
- _PyErr_SetString(tstate, PyExc_RuntimeError,
- "unable to get sys.path_hooks");
return -1;
}
int err = PyList_Insert(path_hooks, 0, zipimporter);
Py_DECREF(zipimporter);
if (err < 0) {
+ Py_DECREF(path_hooks);
return -1;
}
if (verbose) {
PySys_WriteStderr("# installed zipimport hook\n");
}
}
+ Py_DECREF(path_hooks);
return 0;
}
#include "pycore_pylifecycle.h" // _Py_PreInitializeFromConfig()
#include "pycore_pymem.h" // _PyMem_SetDefaultAllocator()
#include "pycore_pystate.h" // _PyThreadState_GET()
+#include "pycore_sysmodule.h" // _PySys_GetOptionalAttrString()
#include "osdefs.h" // DELIM
#define DUMP_SYS(NAME) \
do { \
- obj = PySys_GetObject(#NAME); \
PySys_FormatStderr(" sys.%s = ", #NAME); \
+ if (_PySys_GetOptionalAttrString(#NAME, &obj) < 0) { \
+ PyErr_Clear(); \
+ } \
if (obj != NULL) { \
PySys_FormatStderr("%A", obj); \
+ Py_DECREF(obj); \
} \
else { \
PySys_WriteStderr("(not set)"); \
DUMP_SYS(exec_prefix);
#undef DUMP_SYS
- PyObject *sys_path = PySys_GetObject("path"); /* borrowed reference */
+ PyObject *sys_path;
+ (void) _PySys_GetOptionalAttrString("path", &sys_path);
if (sys_path != NULL && PyList_Check(sys_path)) {
PySys_WriteStderr(" sys.path = [\n");
Py_ssize_t len = PyList_GET_SIZE(sys_path);
}
PySys_WriteStderr(" ]\n");
}
+ Py_XDECREF(sys_path);
_PyErr_SetRaisedException(tstate, exc);
}
#include "pycore_global_objects.h"
#include "pycore_intrinsics.h"
#include "pycore_pyerrors.h"
+#include "pycore_sysmodule.h" // _PySys_GetRequiredAttr()
#include "pycore_typevarobject.h"
}
static PyObject *
-print_expr(PyThreadState* tstate, PyObject *value)
+print_expr(PyThreadState* Py_UNUSED(ignored), PyObject *value)
{
- PyObject *hook = _PySys_GetAttr(tstate, &_Py_ID(displayhook));
+ PyObject *hook = _PySys_GetRequiredAttr(&_Py_ID(displayhook));
// Can't use ERROR_IF here.
if (hook == NULL) {
- _PyErr_SetString(tstate, PyExc_RuntimeError,
- "lost sys.displayhook");
return NULL;
}
- return PyObject_CallOneArg(hook, value);
+ PyObject *res = PyObject_CallOneArg(hook, value);
+ Py_DECREF(hook);
+ return res;
}
static int
if (is_main_interp) {
/* Initialize warnings. */
- PyObject *warnoptions = PySys_GetObject("warnoptions");
- if (warnoptions != NULL && PyList_Size(warnoptions) > 0)
+ PyObject *warnoptions;
+ if (_PySys_GetOptionalAttrString("warnoptions", &warnoptions) < 0) {
+ return _PyStatus_ERR("can't initialize warnings");
+ }
+ if (warnoptions != NULL && PyList_Check(warnoptions) &&
+ PyList_Size(warnoptions) > 0)
{
PyObject *warnings_module = PyImport_ImportModule("warnings");
if (warnings_module == NULL) {
}
Py_XDECREF(warnings_module);
}
+ Py_XDECREF(warnoptions);
interp->runtime->initialized = 1;
}
static int
flush_std_files(void)
{
- PyThreadState *tstate = _PyThreadState_GET();
- PyObject *fout = _PySys_GetAttr(tstate, &_Py_ID(stdout));
- PyObject *ferr = _PySys_GetAttr(tstate, &_Py_ID(stderr));
+ PyObject *file;
PyObject *tmp;
int status = 0;
- if (fout != NULL && fout != Py_None && !file_is_closed(fout)) {
- tmp = PyObject_CallMethodNoArgs(fout, &_Py_ID(flush));
+ if (_PySys_GetOptionalAttr(&_Py_ID(stdout), &file) < 0) {
+ status = -1;
+ }
+ else if (file != NULL && file != Py_None && !file_is_closed(file)) {
+ tmp = PyObject_CallMethodNoArgs(file, &_Py_ID(flush));
if (tmp == NULL) {
- PyErr_WriteUnraisable(fout);
status = -1;
}
else
Py_DECREF(tmp);
}
+ if (status < 0) {
+ PyErr_WriteUnraisable(file);
+ }
+ Py_XDECREF(file);
- if (ferr != NULL && ferr != Py_None && !file_is_closed(ferr)) {
- tmp = PyObject_CallMethodNoArgs(ferr, &_Py_ID(flush));
+ if (_PySys_GetOptionalAttr(&_Py_ID(stderr), &file) < 0) {
+ PyErr_Clear();
+ status = -1;
+ }
+ else if (file != NULL && file != Py_None && !file_is_closed(file)) {
+ tmp = PyObject_CallMethodNoArgs(file, &_Py_ID(flush));
if (tmp == NULL) {
PyErr_Clear();
status = -1;
else
Py_DECREF(tmp);
}
+ Py_XDECREF(file);
return status;
}
return 0;
}
- PyObject *ferr = _PySys_GetAttr(tstate, &_Py_ID(stderr));
+ PyObject *ferr;
+ if (_PySys_GetOptionalAttr(&_Py_ID(stderr), &ferr) < 0) {
+ _PyErr_Clear(tstate);
+ }
if (ferr == NULL || ferr == Py_None) {
/* sys.stderr is not set yet or set to None,
no need to try to display the exception */
+ Py_XDECREF(ferr);
Py_DECREF(exc);
return 0;
}
else {
Py_DECREF(res);
}
+ Py_DECREF(ferr);
return has_tb;
}
flags = &local_flags;
}
- PyThreadState *tstate = _PyThreadState_GET();
- PyObject *v = _PySys_GetAttr(tstate, &_Py_ID(ps1));
+ PyObject *v;
+ if (_PySys_GetOptionalAttr(&_Py_ID(ps1), &v) < 0) {
+ PyErr_Print();
+ return -1;
+ }
if (v == NULL) {
- _PySys_SetAttr(&_Py_ID(ps1), v = PyUnicode_FromString(">>> "));
- Py_XDECREF(v);
+ v = PyUnicode_FromString(">>> ");
+ if (v == NULL) {
+ PyErr_Clear();
+ }
+ if (_PySys_SetAttr(&_Py_ID(ps1), v) < 0) {
+ PyErr_Clear();
+ }
+ }
+ Py_XDECREF(v);
+ if (_PySys_GetOptionalAttr(&_Py_ID(ps2), &v) < 0) {
+ PyErr_Print();
+ return -1;
}
- v = _PySys_GetAttr(tstate, &_Py_ID(ps2));
if (v == NULL) {
- _PySys_SetAttr(&_Py_ID(ps2), v = PyUnicode_FromString("... "));
- Py_XDECREF(v);
+ v = PyUnicode_FromString("... ");
+ if (v == NULL) {
+ PyErr_Clear();
+ }
+ if (_PySys_SetAttr(&_Py_ID(ps2), v) < 0) {
+ PyErr_Clear();
+ }
}
+ Py_XDECREF(v);
#ifdef Py_REF_DEBUG
int show_ref_count = _Py_GetConfig()->show_ref_count;
PyArena *arena;
const char *ps1 = "", *ps2 = "", *enc = NULL;
int errcode = 0;
- PyThreadState *tstate = _PyThreadState_GET();
if (fp == stdin) {
/* Fetch encoding from sys.stdin if possible. */
- v = _PySys_GetAttr(tstate, &_Py_ID(stdin));
+ if (_PySys_GetOptionalAttr(&_Py_ID(stdin), &v) < 0) {
+ return -1;
+ }
if (v && v != Py_None) {
oenc = PyObject_GetAttr(v, &_Py_ID(encoding));
if (oenc)
if (!enc)
PyErr_Clear();
}
+ Py_XDECREF(v);
+ }
+ if (_PySys_GetOptionalAttr(&_Py_ID(ps1), &v) < 0) {
+ Py_XDECREF(oenc);
+ return -1;
}
- v = _PySys_GetAttr(tstate, &_Py_ID(ps1));
if (v != NULL) {
- v = PyObject_Str(v);
+ Py_SETREF(v, PyObject_Str(v));
if (v == NULL)
PyErr_Clear();
else if (PyUnicode_Check(v)) {
}
}
}
- w = _PySys_GetAttr(tstate, &_Py_ID(ps2));
+ if (_PySys_GetOptionalAttr(&_Py_ID(ps2), &w) < 0) {
+ Py_XDECREF(oenc);
+ return -1;
+ }
if (w != NULL) {
- w = PyObject_Str(w);
+ Py_SETREF(w, PyObject_Str(w));
if (w == NULL)
PyErr_Clear();
else if (PyUnicode_Check(w)) {
exitcode = (int)PyLong_AsLong(exc);
}
else {
- PyThreadState *tstate = _PyThreadState_GET();
- PyObject *sys_stderr = _PySys_GetAttr(tstate, &_Py_ID(stderr));
+ PyObject *sys_stderr;
+ (void) _PySys_GetOptionalAttr(&_Py_ID(stderr), &sys_stderr);
/* We clear the exception here to avoid triggering the assertion
* in PyObject_Str that ensures it won't silently lose exception
* details.
PyObject_Print(exc, stderr, Py_PRINT_RAW);
fflush(stderr);
}
+ Py_XDECREF(sys_stderr);
PySys_WriteStderr("\n");
exitcode = 1;
}
static void
_PyErr_PrintEx(PyThreadState *tstate, int set_sys_last_vars)
{
- PyObject *typ = NULL, *tb = NULL;
+ PyObject *typ = NULL, *tb = NULL, *hook = NULL;
handle_system_exit();
PyObject *exc = _PyErr_GetRaisedException(tstate);
_PyErr_Clear(tstate);
}
}
- PyObject *hook = _PySys_GetAttr(tstate, &_Py_ID(excepthook));
+ if (_PySys_GetOptionalAttr(&_Py_ID(excepthook), &hook) < 0) {
+ PyErr_Clear();
+ }
if (_PySys_Audit(tstate, "sys.excepthook", "OOOO", hook ? hook : Py_None,
typ, exc, tb) < 0) {
if (PyErr_ExceptionMatches(PyExc_RuntimeError)) {
}
done:
+ Py_XDECREF(hook);
Py_XDECREF(typ);
Py_XDECREF(exc);
Py_XDECREF(tb);
void
PyErr_Display(PyObject *unused, PyObject *value, PyObject *tb)
{
- PyThreadState *tstate = _PyThreadState_GET();
- PyObject *file = _PySys_GetAttr(tstate, &_Py_ID(stderr));
+ PyObject *file;
+ if (_PySys_GetOptionalAttr(&_Py_ID(stderr), &file) < 0) {
+ PyObject *exc = PyErr_GetRaisedException();
+ _PyObject_Dump(value);
+ fprintf(stderr, "lost sys.stderr\n");
+ _PyObject_Dump(exc);
+ Py_DECREF(exc);
+ return;
+ }
if (file == NULL) {
_PyObject_Dump(value);
fprintf(stderr, "lost sys.stderr\n");
return;
}
if (file == Py_None) {
+ Py_DECREF(file);
return;
}
- Py_INCREF(file);
_PyErr_Display(file, NULL, value, tb);
Py_DECREF(file);
}
static void
flush_io_stream(PyThreadState *tstate, PyObject *name)
{
- PyObject *f = _PySys_GetAttr(tstate, name);
+ PyObject *f;
+ if (_PySys_GetOptionalAttr(name, &f) < 0) {
+ PyErr_Clear();
+ }
if (f != NULL) {
PyObject *r = _PyObject_CallMethodNoArgs(f, &_Py_ID(flush));
if (r) {
else {
PyErr_Clear();
}
+ Py_DECREF(f);
}
}
#include "pycore_pymem.h" // _PyMem_SetDefaultAllocator()
#include "pycore_pystate.h" // _PyThreadState_GET()
#include "pycore_structseq.h" // _PyStructSequence_InitBuiltinWithFlags()
+#include "pycore_sysmodule.h"
#include "pycore_tuple.h" // _PyTuple_FromArray()
#include "frameobject.h" // PyFrame_FastToLocalsWithError()
return value;
}
-static PyObject *
-_PySys_GetObject(PyInterpreterState *interp, const char *name)
+ PyObject *
+_PySys_GetRequiredAttr(PyObject *name)
{
- PyObject *sysdict = interp->sysdict;
+ if (!PyUnicode_Check(name)) {
+ PyErr_Format(PyExc_TypeError,
+ "attribute name must be string, not '%.200s'",
+ Py_TYPE(name)->tp_name);
+ return NULL;
+ }
+ PyThreadState *tstate = _PyThreadState_GET();
+ PyObject *sysdict = tstate->interp->sysdict;
if (sysdict == NULL) {
+ PyErr_SetString(PyExc_RuntimeError, "no sys module");
return NULL;
}
- return _PyDict_GetItemStringWithError(sysdict, name);
+ PyObject *value = _PyDict_GetItemWithError(sysdict, name);
+ Py_XINCREF(value);
+ if (value == NULL && !_PyErr_Occurred(tstate)) {
+ PyErr_Format(PyExc_RuntimeError, "lost sys.%U", name);
+ }
+ return value;
}
PyObject *
-PySys_GetObject(const char *name)
+_PySys_GetRequiredAttrString(const char *name)
{
PyThreadState *tstate = _PyThreadState_GET();
+ PyObject *sysdict = tstate->interp->sysdict;
+ if (sysdict == NULL) {
+ PyErr_SetString(PyExc_RuntimeError, "no sys module");
+ return NULL;
+ }
+ PyObject *value = _PyDict_GetItemStringWithError(sysdict, name);
+ Py_XINCREF(value);
+ if (value == NULL && !_PyErr_Occurred(tstate)) {
+ PyErr_Format(PyExc_RuntimeError, "lost sys.%s", name);
+ }
+ return value;
+}
+int
+_PySys_GetOptionalAttr(PyObject *name, PyObject **value)
+{
+ if (!PyUnicode_Check(name)) {
+ PyErr_Format(PyExc_TypeError,
+ "attribute name must be string, not '%.200s'",
+ Py_TYPE(name)->tp_name);
+ *value = NULL;
+ return -1;
+ }
+ PyThreadState *tstate = _PyThreadState_GET();
+ PyObject *sysdict = tstate->interp->sysdict;
+ if (sysdict == NULL) {
+ *value = NULL;
+ return 0;
+ }
+ *value = _PyDict_GetItemWithError(sysdict, name);
+ if (*value) {
+ Py_INCREF(*value);
+ return 1;
+ }
+ return _PyErr_Occurred(tstate) ? -1 : 0;
+}
+
+int
+_PySys_GetOptionalAttrString(const char *name, PyObject **value)
+{
+ PyThreadState *tstate = _PyThreadState_GET();
+ PyObject *sysdict = tstate->interp->sysdict;
+ if (sysdict == NULL) {
+ *value = NULL;
+ return 0;
+ }
+ *value = _PyDict_GetItemStringWithError(sysdict, name);
+ if (*value) {
+ Py_INCREF(*value);
+ return 1;
+ }
+ return _PyErr_Occurred(tstate) ? -1 : 0;
+}
+
+PyObject *
+PySys_GetObject(const char *name)
+{
+ PyThreadState *tstate = _PyThreadState_GET();
+ PyObject *sysdict = tstate->interp->sysdict;
+ if (sysdict == NULL) {
+ return NULL;
+ }
PyObject *exc = _PyErr_GetRaisedException(tstate);
- PyObject *value = _PySys_GetObject(tstate->interp, name);
+ PyObject *value = _PyDict_GetItemStringWithError(sysdict, name);
/* XXX Suppress a new exception if it was raised and restore
* the old one. */
_PyErr_SetRaisedException(tstate, exc);
return -1;
}
PyObject *sd = interp->sysdict;
+ if (sd == NULL) {
+ PyErr_SetString(PyExc_RuntimeError, "no sys module");
+ return -1;
+ }
if (v == NULL) {
v = _PyDict_Pop(sd, key, Py_None);
if (v == NULL) {
}
if (PyObject_SetAttr(builtins, _Py_LATIN1_CHR('_'), Py_None) != 0)
return NULL;
- outf = _PySys_GetAttr(tstate, &_Py_ID(stdout));
- if (outf == NULL || outf == Py_None) {
+ outf = _PySys_GetRequiredAttr(&_Py_ID(stdout));
+ if (outf == NULL) {
+ return NULL;
+ }
+ if (outf == Py_None) {
_PyErr_SetString(tstate, PyExc_RuntimeError, "lost sys.stdout");
+ Py_DECREF(outf);
return NULL;
}
if (PyFile_WriteObject(o, outf, 0) != 0) {
_PyErr_Clear(tstate);
err = sys_displayhook_unencodable(outf, o);
if (err) {
+ Py_DECREF(outf);
return NULL;
}
}
else {
+ Py_DECREF(outf);
return NULL;
}
}
- if (PyFile_WriteObject(_Py_LATIN1_CHR('\n'), outf, Py_PRINT_RAW) != 0)
+ if (PyFile_WriteObject(_Py_LATIN1_CHR('\n'), outf, Py_PRINT_RAW) != 0) {
+ Py_DECREF(outf);
return NULL;
- if (PyObject_SetAttr(builtins, _Py_LATIN1_CHR('_'), o) != 0)
+ }
+ Py_DECREF(outf);
+ if (PyObject_SetAttr(builtins, _Py_LATIN1_CHR('_'), o) != 0) {
return NULL;
+ }
Py_RETURN_NONE;
}
static PyObject *
get_warnoptions(PyThreadState *tstate)
{
- PyObject *warnoptions = _PySys_GetAttr(tstate, &_Py_ID(warnoptions));
+ PyObject *warnoptions;
+ if (_PySys_GetOptionalAttr(&_Py_ID(warnoptions), &warnoptions) < 0) {
+ return NULL;
+ }
if (warnoptions == NULL || !PyList_Check(warnoptions)) {
/* PEP432 TODO: we can reach this if warnoptions is NULL in the main
* interpreter config. When that happens, we need to properly set
* call optional for embedding applications, thus making this
* reachable again.
*/
+ Py_XDECREF(warnoptions);
warnoptions = PyList_New(0);
if (warnoptions == NULL) {
return NULL;
Py_DECREF(warnoptions);
return NULL;
}
- Py_DECREF(warnoptions);
}
return warnoptions;
}
return;
}
- PyObject *warnoptions = _PySys_GetAttr(tstate, &_Py_ID(warnoptions));
- if (warnoptions == NULL || !PyList_Check(warnoptions))
+ PyObject *warnoptions;
+ if (_PySys_GetOptionalAttr(&_Py_ID(warnoptions), &warnoptions) < 0) {
+ PyErr_Clear();
return;
- PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL);
+ }
+ if (warnoptions != NULL && PyList_Check(warnoptions)) {
+ PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL);
+ }
+ Py_XDECREF(warnoptions);
}
static int
return -1;
}
if (PyList_Append(warnoptions, option)) {
+ Py_DECREF(warnoptions);
return -1;
}
+ Py_DECREF(warnoptions);
return 0;
}
int
PySys_HasWarnOptions(void)
{
- PyThreadState *tstate = _PyThreadState_GET();
- PyObject *warnoptions = _PySys_GetAttr(tstate, &_Py_ID(warnoptions));
- return (warnoptions != NULL && PyList_Check(warnoptions)
- && PyList_GET_SIZE(warnoptions) > 0);
+ PyObject *warnoptions;
+ if (_PySys_GetOptionalAttr(&_Py_ID(warnoptions), &warnoptions) < 0) {
+ PyErr_Clear();
+ return 0;
+ }
+ int r = (warnoptions != NULL && PyList_Check(warnoptions) &&
+ PyList_GET_SIZE(warnoptions) > 0);
+ Py_XDECREF(warnoptions);
+ return r;
}
static PyObject *
get_xoptions(PyThreadState *tstate)
{
- PyObject *xoptions = _PySys_GetAttr(tstate, &_Py_ID(_xoptions));
+ PyObject *xoptions;
+ if (_PySys_GetOptionalAttr(&_Py_ID(_xoptions), &xoptions) < 0) {
+ return NULL;
+ }
if (xoptions == NULL || !PyDict_Check(xoptions)) {
/* PEP432 TODO: we can reach this if xoptions is NULL in the main
* interpreter config. When that happens, we need to properly set
* call optional for embedding applications, thus making this
* reachable again.
*/
+ Py_XDECREF(xoptions);
xoptions = PyDict_New();
if (xoptions == NULL) {
return NULL;
Py_DECREF(xoptions);
return NULL;
}
- Py_DECREF(xoptions);
}
return xoptions;
}
}
Py_DECREF(name);
Py_DECREF(value);
+ Py_DECREF(opts);
return 0;
error:
Py_XDECREF(name);
Py_XDECREF(value);
+ Py_XDECREF(opts);
return -1;
}
PySys_GetXOptions(void)
{
PyThreadState *tstate = _PyThreadState_GET();
- return get_xoptions(tstate);
+ PyObject *opts = get_xoptions(tstate);
+ Py_XDECREF(opts);
+ return opts;
}
/* XXX This doc string is too long to be a single string literal in VC++ 5.0.
#undef COPY_WSTR
// sys.flags
- PyObject *flags = _PySys_GetObject(interp, "flags"); // borrowed ref
+ PyObject *flags = _PySys_GetRequiredAttrString("flags");
if (flags == NULL) {
- if (!_PyErr_Occurred(tstate)) {
- _PyErr_SetString(tstate, PyExc_RuntimeError, "lost sys.flags");
- }
return -1;
}
if (set_flags_from_config(interp, flags) < 0) {
+ Py_DECREF(flags);
return -1;
}
+ Py_DECREF(flags);
SET_SYS("dont_write_bytecode", PyBool_FromLong(!config->write_bytecode));
Py_FatalError("can't compute path0 from argv");
}
- PyObject *sys_path = _PySys_GetAttr(tstate, &_Py_ID(path));
- if (sys_path != NULL) {
+ PyObject *sys_path;
+ if (_PySys_GetOptionalAttr(&_Py_ID(path), &sys_path) < 0) {
+ Py_FatalError("can't get sys.path");
+ }
+ else if (sys_path != NULL) {
if (PyList_Insert(sys_path, 0, path0) < 0) {
- Py_DECREF(path0);
Py_FatalError("can't prepend path0 to sys.path");
}
+ Py_DECREF(sys_path);
}
Py_DECREF(path0);
}
PyThreadState *tstate = _PyThreadState_GET();
PyObject *exc = _PyErr_GetRaisedException(tstate);
- file = _PySys_GetAttr(tstate, key);
written = PyOS_vsnprintf(buffer, sizeof(buffer), format, va);
+ file = _PySys_GetRequiredAttr(key);
if (sys_pyfile_write(buffer, file) != 0) {
_PyErr_Clear(tstate);
fputs(buffer, fp);
if (sys_pyfile_write(truncated, file) != 0)
fputs(truncated, fp);
}
+ Py_XDECREF(file);
_PyErr_SetRaisedException(tstate, exc);
}
PyThreadState *tstate = _PyThreadState_GET();
PyObject *exc = _PyErr_GetRaisedException(tstate);
- file = _PySys_GetAttr(tstate, key);
message = PyUnicode_FromFormatV(format, va);
if (message != NULL) {
+ file = _PySys_GetRequiredAttr(key);
if (sys_pyfile_write_unicode(message, file) != 0) {
_PyErr_Clear(tstate);
utf8 = PyUnicode_AsUTF8(message);
if (utf8 != NULL)
fputs(utf8, fp);
}
+ Py_XDECREF(file);
Py_DECREF(message);
}
_PyErr_SetRaisedException(tstate, exc);
#include "pycore_pyarena.h" // _PyArena_Free()
#include "pycore_pyerrors.h" // _PyErr_GetRaisedException()
#include "pycore_pystate.h" // _PyThreadState_GET()
+#include "pycore_sysmodule.h" // _PySys_GetOptionalAttr()
#include "pycore_traceback.h" // EXCEPTION_TB_HEADER
#include "../Parser/pegen.h" // _PyPegen_byte_offset_to_character_offset()
taillen = strlen(tail);
PyThreadState *tstate = _PyThreadState_GET();
- syspath = _PySys_GetAttr(tstate, &_Py_ID(path));
- if (syspath == NULL || !PyList_Check(syspath))
+ if (_PySys_GetOptionalAttr(&_Py_ID(path), &syspath) < 0) {
+ PyErr_Clear();
+ goto error;
+ }
+ if (syspath == NULL || !PyList_Check(syspath)) {
goto error;
+ }
npath = PyList_Size(syspath);
open = PyObject_GetAttr(io, &_Py_ID(open));
result = NULL;
finally:
Py_XDECREF(open);
+ Py_XDECREF(syspath);
Py_DECREF(filebytes);
return result;
}
PyErr_BadInternalCall();
return -1;
}
- limitv = PySys_GetObject("tracebacklimit");
- if (limitv && PyLong_Check(limitv)) {
+ if (_PySys_GetOptionalAttrString("tracebacklimit", &limitv) < 0) {
+ return -1;
+ }
+ else if (limitv != NULL && PyLong_Check(limitv)) {
int overflow;
limit = PyLong_AsLongAndOverflow(limitv, &overflow);
if (overflow > 0) {
limit = LONG_MAX;
}
else if (limit <= 0) {
+ Py_DECREF(limitv);
return 0;
}
}
+ Py_XDECREF(limitv);
if (_Py_WriteIndentedMargin(indent, header_margin, f) < 0) {
return -1;
}
projects / thirdparty / Python / cpython.git / commitdiff
