| /* Python interpreter top-level routines, including init/exit */ |
| |
| #include "Python.h" |
| |
| #include "Python-ast.h" |
| #undef Yield /* undefine macro conflicting with winbase.h */ |
| #include "grammar.h" |
| #include "node.h" |
| #include "token.h" |
| #include "parsetok.h" |
| #include "errcode.h" |
| #include "code.h" |
| #include "symtable.h" |
| #include "ast.h" |
| #include "marshal.h" |
| #include "osdefs.h" |
| #include <locale.h> |
| |
| #ifdef HAVE_SIGNAL_H |
| #include <signal.h> |
| #endif |
| |
| #ifdef MS_WINDOWS |
| #include "malloc.h" /* for alloca */ |
| #endif |
| |
| #ifdef HAVE_LANGINFO_H |
| #include <langinfo.h> |
| #endif |
| |
| #ifdef MS_WINDOWS |
| #undef BYTE |
| #include "windows.h" |
| #endif |
| |
| _Py_IDENTIFIER(flush); |
| _Py_IDENTIFIER(name); |
| _Py_IDENTIFIER(stdin); |
| _Py_IDENTIFIER(stdout); |
| _Py_IDENTIFIER(stderr); |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| extern wchar_t *Py_GetPath(void); |
| |
| extern grammar _PyParser_Grammar; /* From graminit.c */ |
| |
| /* Forward */ |
| static void initmain(PyInterpreterState *interp); |
| static int initfsencoding(PyInterpreterState *interp); |
| static void initsite(void); |
| static int initstdio(void); |
| static void initsigs(void); |
| static void call_py_exitfuncs(void); |
| static void wait_for_thread_shutdown(void); |
| static void call_ll_exitfuncs(void); |
| extern int _PyUnicode_Init(void); |
| extern int _PyStructSequence_Init(void); |
| extern void _PyUnicode_Fini(void); |
| extern int _PyLong_Init(void); |
| extern void PyLong_Fini(void); |
| extern int _PyFaulthandler_Init(void); |
| extern void _PyFaulthandler_Fini(void); |
| extern void _PyHash_Fini(void); |
| extern int _PyTraceMalloc_Init(void); |
| extern int _PyTraceMalloc_Fini(void); |
| |
| #ifdef WITH_THREAD |
| extern void _PyGILState_Init(PyInterpreterState *, PyThreadState *); |
| extern void _PyGILState_Fini(void); |
| #endif /* WITH_THREAD */ |
| |
| /* Global configuration variable declarations are in pydebug.h */ |
| /* XXX (ncoghlan): move those declarations to pylifecycle.h? */ |
| int Py_DebugFlag; /* Needed by parser.c */ |
| int Py_VerboseFlag; /* Needed by import.c */ |
| int Py_QuietFlag; /* Needed by sysmodule.c */ |
| int Py_InteractiveFlag; /* Needed by Py_FdIsInteractive() below */ |
| int Py_InspectFlag; /* Needed to determine whether to exit at SystemExit */ |
| int Py_OptimizeFlag = 0; /* Needed by compile.c */ |
| int Py_NoSiteFlag; /* Suppress 'import site' */ |
| int Py_BytesWarningFlag; /* Warn on str(bytes) and str(buffer) */ |
| int Py_UseClassExceptionsFlag = 1; /* Needed by bltinmodule.c: deprecated */ |
| int Py_FrozenFlag; /* Needed by getpath.c */ |
| int Py_IgnoreEnvironmentFlag; /* e.g. PYTHONPATH, PYTHONHOME */ |
| int Py_DontWriteBytecodeFlag; /* Suppress writing bytecode files (*.py[co]) */ |
| int Py_NoUserSiteDirectory = 0; /* for -s and site.py */ |
| int Py_UnbufferedStdioFlag = 0; /* Unbuffered binary std{in,out,err} */ |
| int Py_HashRandomizationFlag = 0; /* for -R and PYTHONHASHSEED */ |
| int Py_IsolatedFlag = 0; /* for -I, isolate from user's env */ |
| #ifdef MS_WINDOWS |
| int Py_LegacyWindowsFSEncodingFlag = 0; /* Uses mbcs instead of utf-8 */ |
| #endif |
| |
| PyThreadState *_Py_Finalizing = NULL; |
| |
| /* Hack to force loading of object files */ |
| int (*_PyOS_mystrnicmp_hack)(const char *, const char *, Py_ssize_t) = \ |
| PyOS_mystrnicmp; /* Python/pystrcmp.o */ |
| |
| /* PyModule_GetWarningsModule is no longer necessary as of 2.6 |
| since _warnings is builtin. This API should not be used. */ |
| PyObject * |
| PyModule_GetWarningsModule(void) |
| { |
| return PyImport_ImportModule("warnings"); |
| } |
| |
| static int initialized = 0; |
| |
| /* API to access the initialized flag -- useful for esoteric use */ |
| |
| int |
| Py_IsInitialized(void) |
| { |
| return initialized; |
| } |
| |
| /* Helper to allow an embedding application to override the normal |
| * mechanism that attempts to figure out an appropriate IO encoding |
| */ |
| |
| static char *_Py_StandardStreamEncoding = NULL; |
| static char *_Py_StandardStreamErrors = NULL; |
| |
| int |
| Py_SetStandardStreamEncoding(const char *encoding, const char *errors) |
| { |
| if (Py_IsInitialized()) { |
| /* This is too late to have any effect */ |
| return -1; |
| } |
| /* Can't call PyErr_NoMemory() on errors, as Python hasn't been |
| * initialised yet. |
| * |
| * However, the raw memory allocators are initialised appropriately |
| * as C static variables, so _PyMem_RawStrdup is OK even though |
| * Py_Initialize hasn't been called yet. |
| */ |
| if (encoding) { |
| _Py_StandardStreamEncoding = _PyMem_RawStrdup(encoding); |
| if (!_Py_StandardStreamEncoding) { |
| return -2; |
| } |
| } |
| if (errors) { |
| _Py_StandardStreamErrors = _PyMem_RawStrdup(errors); |
| if (!_Py_StandardStreamErrors) { |
| if (_Py_StandardStreamEncoding) { |
| PyMem_RawFree(_Py_StandardStreamEncoding); |
| } |
| return -3; |
| } |
| } |
| return 0; |
| } |
| |
| /* Global initializations. Can be undone by Py_FinalizeEx(). Don't |
| call this twice without an intervening Py_FinalizeEx() call. When |
| initializations fail, a fatal error is issued and the function does |
| not return. On return, the first thread and interpreter state have |
| been created. |
| |
| Locking: you must hold the interpreter lock while calling this. |
| (If the lock has not yet been initialized, that's equivalent to |
| having the lock, but you cannot use multiple threads.) |
| |
| */ |
| |
| static int |
| add_flag(int flag, const char *envs) |
| { |
| int env = atoi(envs); |
| if (flag < env) |
| flag = env; |
| if (flag < 1) |
| flag = 1; |
| return flag; |
| } |
| |
| static char* |
| get_codec_name(const char *encoding) |
| { |
| char *name_utf8, *name_str; |
| PyObject *codec, *name = NULL; |
| |
| codec = _PyCodec_Lookup(encoding); |
| if (!codec) |
| goto error; |
| |
| name = _PyObject_GetAttrId(codec, &PyId_name); |
| Py_CLEAR(codec); |
| if (!name) |
| goto error; |
| |
| name_utf8 = _PyUnicode_AsString(name); |
| if (name_utf8 == NULL) |
| goto error; |
| name_str = _PyMem_RawStrdup(name_utf8); |
| Py_DECREF(name); |
| if (name_str == NULL) { |
| PyErr_NoMemory(); |
| return NULL; |
| } |
| return name_str; |
| |
| error: |
| Py_XDECREF(codec); |
| Py_XDECREF(name); |
| return NULL; |
| } |
| |
| static char* |
| get_locale_encoding(void) |
| { |
| #ifdef MS_WINDOWS |
| char codepage[100]; |
| PyOS_snprintf(codepage, sizeof(codepage), "cp%d", GetACP()); |
| return get_codec_name(codepage); |
| #elif defined(HAVE_LANGINFO_H) && defined(CODESET) |
| char* codeset = nl_langinfo(CODESET); |
| if (!codeset || codeset[0] == '\0') { |
| PyErr_SetString(PyExc_ValueError, "CODESET is not set or empty"); |
| return NULL; |
| } |
| return get_codec_name(codeset); |
| #elif defined(__ANDROID__) |
| return get_codec_name("UTF-8"); |
| #else |
| PyErr_SetNone(PyExc_NotImplementedError); |
| return NULL; |
| #endif |
| } |
| |
| static void |
| import_init(PyInterpreterState *interp, PyObject *sysmod) |
| { |
| PyObject *importlib; |
| PyObject *impmod; |
| PyObject *sys_modules; |
| PyObject *value; |
| |
| /* Import _importlib through its frozen version, _frozen_importlib. */ |
| if (PyImport_ImportFrozenModule("_frozen_importlib") <= 0) { |
| Py_FatalError("Py_Initialize: can't import _frozen_importlib"); |
| } |
| else if (Py_VerboseFlag) { |
| PySys_FormatStderr("import _frozen_importlib # frozen\n"); |
| } |
| importlib = PyImport_AddModule("_frozen_importlib"); |
| if (importlib == NULL) { |
| Py_FatalError("Py_Initialize: couldn't get _frozen_importlib from " |
| "sys.modules"); |
| } |
| interp->importlib = importlib; |
| Py_INCREF(interp->importlib); |
| |
| interp->import_func = PyDict_GetItemString(interp->builtins, "__import__"); |
| if (interp->import_func == NULL) |
| Py_FatalError("Py_Initialize: __import__ not found"); |
| Py_INCREF(interp->import_func); |
| |
| /* Import the _imp module */ |
| impmod = PyInit_imp(); |
| if (impmod == NULL) { |
| Py_FatalError("Py_Initialize: can't import _imp"); |
| } |
| else if (Py_VerboseFlag) { |
| PySys_FormatStderr("import _imp # builtin\n"); |
| } |
| sys_modules = PyImport_GetModuleDict(); |
| if (Py_VerboseFlag) { |
| PySys_FormatStderr("import sys # builtin\n"); |
| } |
| if (PyDict_SetItemString(sys_modules, "_imp", impmod) < 0) { |
| Py_FatalError("Py_Initialize: can't save _imp to sys.modules"); |
| } |
| |
| /* Install importlib as the implementation of import */ |
| value = PyObject_CallMethod(importlib, "_install", "OO", sysmod, impmod); |
| if (value == NULL) { |
| PyErr_Print(); |
| Py_FatalError("Py_Initialize: importlib install failed"); |
| } |
| Py_DECREF(value); |
| Py_DECREF(impmod); |
| |
| _PyImportZip_Init(); |
| } |
| |
| |
| void |
| _Py_InitializeEx_Private(int install_sigs, int install_importlib) |
| { |
| PyInterpreterState *interp; |
| PyThreadState *tstate; |
| PyObject *bimod, *sysmod, *pstderr; |
| char *p; |
| extern void _Py_ReadyTypes(void); |
| |
| if (initialized) |
| return; |
| initialized = 1; |
| _Py_Finalizing = NULL; |
| |
| #if defined(HAVE_LANGINFO_H) && defined(HAVE_SETLOCALE) |
| /* Set up the LC_CTYPE locale, so we can obtain |
| the locale's charset without having to switch |
| locales. */ |
| setlocale(LC_CTYPE, ""); |
| #endif |
| |
| if ((p = Py_GETENV("PYTHONDEBUG")) && *p != '\0') |
| Py_DebugFlag = add_flag(Py_DebugFlag, p); |
| if ((p = Py_GETENV("PYTHONVERBOSE")) && *p != '\0') |
| Py_VerboseFlag = add_flag(Py_VerboseFlag, p); |
| if ((p = Py_GETENV("PYTHONOPTIMIZE")) && *p != '\0') |
| Py_OptimizeFlag = add_flag(Py_OptimizeFlag, p); |
| if ((p = Py_GETENV("PYTHONDONTWRITEBYTECODE")) && *p != '\0') |
| Py_DontWriteBytecodeFlag = add_flag(Py_DontWriteBytecodeFlag, p); |
| /* The variable is only tested for existence here; _PyRandom_Init will |
| check its value further. */ |
| if ((p = Py_GETENV("PYTHONHASHSEED")) && *p != '\0') |
| Py_HashRandomizationFlag = add_flag(Py_HashRandomizationFlag, p); |
| #ifdef MS_WINDOWS |
| if ((p = Py_GETENV("PYTHONLEGACYWINDOWSFSENCODING")) && *p != '\0') |
| Py_LegacyWindowsFSEncodingFlag = add_flag(Py_LegacyWindowsFSEncodingFlag, p); |
| #endif |
| |
| _PyRandom_Init(); |
| |
| interp = PyInterpreterState_New(); |
| if (interp == NULL) |
| Py_FatalError("Py_Initialize: can't make first interpreter"); |
| |
| tstate = PyThreadState_New(interp); |
| if (tstate == NULL) |
| Py_FatalError("Py_Initialize: can't make first thread"); |
| (void) PyThreadState_Swap(tstate); |
| |
| #ifdef WITH_THREAD |
| /* We can't call _PyEval_FiniThreads() in Py_FinalizeEx because |
| destroying the GIL might fail when it is being referenced from |
| another running thread (see issue #9901). |
| Instead we destroy the previously created GIL here, which ensures |
| that we can call Py_Initialize / Py_FinalizeEx multiple times. */ |
| _PyEval_FiniThreads(); |
| |
| /* Auto-thread-state API */ |
| _PyGILState_Init(interp, tstate); |
| #endif /* WITH_THREAD */ |
| |
| _Py_ReadyTypes(); |
| |
| if (!_PyFrame_Init()) |
| Py_FatalError("Py_Initialize: can't init frames"); |
| |
| if (!_PyLong_Init()) |
| Py_FatalError("Py_Initialize: can't init longs"); |
| |
| if (!PyByteArray_Init()) |
| Py_FatalError("Py_Initialize: can't init bytearray"); |
| |
| if (!_PyFloat_Init()) |
| Py_FatalError("Py_Initialize: can't init float"); |
| |
| interp->modules = PyDict_New(); |
| if (interp->modules == NULL) |
| Py_FatalError("Py_Initialize: can't make modules dictionary"); |
| |
| /* Init Unicode implementation; relies on the codec registry */ |
| if (_PyUnicode_Init() < 0) |
| Py_FatalError("Py_Initialize: can't initialize unicode"); |
| if (_PyStructSequence_Init() < 0) |
| Py_FatalError("Py_Initialize: can't initialize structseq"); |
| |
| bimod = _PyBuiltin_Init(); |
| if (bimod == NULL) |
| Py_FatalError("Py_Initialize: can't initialize builtins modules"); |
| _PyImport_FixupBuiltin(bimod, "builtins"); |
| interp->builtins = PyModule_GetDict(bimod); |
| if (interp->builtins == NULL) |
| Py_FatalError("Py_Initialize: can't initialize builtins dict"); |
| Py_INCREF(interp->builtins); |
| |
| /* initialize builtin exceptions */ |
| _PyExc_Init(bimod); |
| |
| sysmod = _PySys_Init(); |
| if (sysmod == NULL) |
| Py_FatalError("Py_Initialize: can't initialize sys"); |
| interp->sysdict = PyModule_GetDict(sysmod); |
| if (interp->sysdict == NULL) |
| Py_FatalError("Py_Initialize: can't initialize sys dict"); |
| Py_INCREF(interp->sysdict); |
| _PyImport_FixupBuiltin(sysmod, "sys"); |
| PySys_SetPath(Py_GetPath()); |
| PyDict_SetItemString(interp->sysdict, "modules", |
| interp->modules); |
| |
| /* Set up a preliminary stderr printer until we have enough |
| infrastructure for the io module in place. */ |
| pstderr = PyFile_NewStdPrinter(fileno(stderr)); |
| if (pstderr == NULL) |
| Py_FatalError("Py_Initialize: can't set preliminary stderr"); |
| _PySys_SetObjectId(&PyId_stderr, pstderr); |
| PySys_SetObject("__stderr__", pstderr); |
| Py_DECREF(pstderr); |
| |
| _PyImport_Init(); |
| |
| _PyImportHooks_Init(); |
| |
| /* Initialize _warnings. */ |
| _PyWarnings_Init(); |
| |
| if (!install_importlib) |
| return; |
| |
| if (_PyTime_Init() < 0) |
| Py_FatalError("Py_Initialize: can't initialize time"); |
| |
| import_init(interp, sysmod); |
| |
| /* initialize the faulthandler module */ |
| if (_PyFaulthandler_Init()) |
| Py_FatalError("Py_Initialize: can't initialize faulthandler"); |
| |
| if (initfsencoding(interp) < 0) |
| Py_FatalError("Py_Initialize: unable to load the file system codec"); |
| |
| if (install_sigs) |
| initsigs(); /* Signal handling stuff, including initintr() */ |
| |
| if (_PyTraceMalloc_Init() < 0) |
| Py_FatalError("Py_Initialize: can't initialize tracemalloc"); |
| |
| initmain(interp); /* Module __main__ */ |
| if (initstdio() < 0) |
| Py_FatalError( |
| "Py_Initialize: can't initialize sys standard streams"); |
| |
| /* Initialize warnings. */ |
| if (PySys_HasWarnOptions()) { |
| PyObject *warnings_module = PyImport_ImportModule("warnings"); |
| if (warnings_module == NULL) { |
| fprintf(stderr, "'import warnings' failed; traceback:\n"); |
| PyErr_Print(); |
| } |
| Py_XDECREF(warnings_module); |
| } |
| |
| if (!Py_NoSiteFlag) |
| initsite(); /* Module site */ |
| } |
| |
| void |
| Py_InitializeEx(int install_sigs) |
| { |
| _Py_InitializeEx_Private(install_sigs, 1); |
| } |
| |
| void |
| Py_Initialize(void) |
| { |
| Py_InitializeEx(1); |
| } |
| |
| |
| #ifdef COUNT_ALLOCS |
| extern void dump_counts(FILE*); |
| #endif |
| |
| /* Flush stdout and stderr */ |
| |
| static int |
| file_is_closed(PyObject *fobj) |
| { |
| int r; |
| PyObject *tmp = PyObject_GetAttrString(fobj, "closed"); |
| if (tmp == NULL) { |
| PyErr_Clear(); |
| return 0; |
| } |
| r = PyObject_IsTrue(tmp); |
| Py_DECREF(tmp); |
| if (r < 0) |
| PyErr_Clear(); |
| return r > 0; |
| } |
| |
| static int |
| flush_std_files(void) |
| { |
| PyObject *fout = _PySys_GetObjectId(&PyId_stdout); |
| PyObject *ferr = _PySys_GetObjectId(&PyId_stderr); |
| PyObject *tmp; |
| int status = 0; |
| |
| if (fout != NULL && fout != Py_None && !file_is_closed(fout)) { |
| tmp = _PyObject_CallMethodId(fout, &PyId_flush, NULL); |
| if (tmp == NULL) { |
| PyErr_WriteUnraisable(fout); |
| status = -1; |
| } |
| else |
| Py_DECREF(tmp); |
| } |
| |
| if (ferr != NULL && ferr != Py_None && !file_is_closed(ferr)) { |
| tmp = _PyObject_CallMethodId(ferr, &PyId_flush, NULL); |
| if (tmp == NULL) { |
| PyErr_Clear(); |
| status = -1; |
| } |
| else |
| Py_DECREF(tmp); |
| } |
| |
| return status; |
| } |
| |
| /* Undo the effect of Py_Initialize(). |
| |
| Beware: if multiple interpreter and/or thread states exist, these |
| are not wiped out; only the current thread and interpreter state |
| are deleted. But since everything else is deleted, those other |
| interpreter and thread states should no longer be used. |
| |
| (XXX We should do better, e.g. wipe out all interpreters and |
| threads.) |
| |
| Locking: as above. |
| |
| */ |
| |
| int |
| Py_FinalizeEx(void) |
| { |
| PyInterpreterState *interp; |
| PyThreadState *tstate; |
| int status = 0; |
| |
| if (!initialized) |
| return status; |
| |
| wait_for_thread_shutdown(); |
| |
| /* The interpreter is still entirely intact at this point, and the |
| * exit funcs may be relying on that. In particular, if some thread |
| * or exit func is still waiting to do an import, the import machinery |
| * expects Py_IsInitialized() to return true. So don't say the |
| * interpreter is uninitialized until after the exit funcs have run. |
| * Note that Threading.py uses an exit func to do a join on all the |
| * threads created thru it, so this also protects pending imports in |
| * the threads created via Threading. |
| */ |
| call_py_exitfuncs(); |
| |
| /* Get current thread state and interpreter pointer */ |
| tstate = PyThreadState_GET(); |
| interp = tstate->interp; |
| |
| /* Remaining threads (e.g. daemon threads) will automatically exit |
| after taking the GIL (in PyEval_RestoreThread()). */ |
| _Py_Finalizing = tstate; |
| initialized = 0; |
| |
| /* Flush sys.stdout and sys.stderr */ |
| if (flush_std_files() < 0) { |
| status = -1; |
| } |
| |
| /* Disable signal handling */ |
| PyOS_FiniInterrupts(); |
| |
| /* Collect garbage. This may call finalizers; it's nice to call these |
| * before all modules are destroyed. |
| * XXX If a __del__ or weakref callback is triggered here, and tries to |
| * XXX import a module, bad things can happen, because Python no |
| * XXX longer believes it's initialized. |
| * XXX Fatal Python error: Interpreter not initialized (version mismatch?) |
| * XXX is easy to provoke that way. I've also seen, e.g., |
| * XXX Exception exceptions.ImportError: 'No module named sha' |
| * XXX in <function callback at 0x008F5718> ignored |
| * XXX but I'm unclear on exactly how that one happens. In any case, |
| * XXX I haven't seen a real-life report of either of these. |
| */ |
| PyGC_Collect(); |
| #ifdef COUNT_ALLOCS |
| /* With COUNT_ALLOCS, it helps to run GC multiple times: |
| each collection might release some types from the type |
| list, so they become garbage. */ |
| while (PyGC_Collect() > 0) |
| /* nothing */; |
| #endif |
| /* Destroy all modules */ |
| PyImport_Cleanup(); |
| |
| /* Flush sys.stdout and sys.stderr (again, in case more was printed) */ |
| if (flush_std_files() < 0) { |
| status = -1; |
| } |
| |
| /* Collect final garbage. This disposes of cycles created by |
| * class definitions, for example. |
| * XXX This is disabled because it caused too many problems. If |
| * XXX a __del__ or weakref callback triggers here, Python code has |
| * XXX a hard time running, because even the sys module has been |
| * XXX cleared out (sys.stdout is gone, sys.excepthook is gone, etc). |
| * XXX One symptom is a sequence of information-free messages |
| * XXX coming from threads (if a __del__ or callback is invoked, |
| * XXX other threads can execute too, and any exception they encounter |
| * XXX triggers a comedy of errors as subsystem after subsystem |
| * XXX fails to find what it *expects* to find in sys to help report |
| * XXX the exception and consequent unexpected failures). I've also |
| * XXX seen segfaults then, after adding print statements to the |
| * XXX Python code getting called. |
| */ |
| #if 0 |
| PyGC_Collect(); |
| #endif |
| |
| /* Disable tracemalloc after all Python objects have been destroyed, |
| so it is possible to use tracemalloc in objects destructor. */ |
| _PyTraceMalloc_Fini(); |
| |
| /* Destroy the database used by _PyImport_{Fixup,Find}Extension */ |
| _PyImport_Fini(); |
| |
| /* Cleanup typeobject.c's internal caches. */ |
| _PyType_Fini(); |
| |
| /* unload faulthandler module */ |
| _PyFaulthandler_Fini(); |
| |
| /* Debugging stuff */ |
| #ifdef COUNT_ALLOCS |
| dump_counts(stderr); |
| #endif |
| /* dump hash stats */ |
| _PyHash_Fini(); |
| |
| _PY_DEBUG_PRINT_TOTAL_REFS(); |
| |
| #ifdef Py_TRACE_REFS |
| /* Display all objects still alive -- this can invoke arbitrary |
| * __repr__ overrides, so requires a mostly-intact interpreter. |
| * Alas, a lot of stuff may still be alive now that will be cleaned |
| * up later. |
| */ |
| if (Py_GETENV("PYTHONDUMPREFS")) |
| _Py_PrintReferences(stderr); |
| #endif /* Py_TRACE_REFS */ |
| |
| /* Clear interpreter state and all thread states. */ |
| PyInterpreterState_Clear(interp); |
| |
| /* Now we decref the exception classes. After this point nothing |
| can raise an exception. That's okay, because each Fini() method |
| below has been checked to make sure no exceptions are ever |
| raised. |
| */ |
| |
| _PyExc_Fini(); |
| |
| /* Sundry finalizers */ |
| PyMethod_Fini(); |
| PyFrame_Fini(); |
| PyCFunction_Fini(); |
| PyTuple_Fini(); |
| PyList_Fini(); |
| PySet_Fini(); |
| PyBytes_Fini(); |
| PyByteArray_Fini(); |
| PyLong_Fini(); |
| PyFloat_Fini(); |
| PyDict_Fini(); |
| PySlice_Fini(); |
| _PyGC_Fini(); |
| _PyRandom_Fini(); |
| _PyArg_Fini(); |
| |
| /* Cleanup Unicode implementation */ |
| _PyUnicode_Fini(); |
| |
| /* reset file system default encoding */ |
| if (!Py_HasFileSystemDefaultEncoding && Py_FileSystemDefaultEncoding) { |
| PyMem_RawFree((char*)Py_FileSystemDefaultEncoding); |
| Py_FileSystemDefaultEncoding = NULL; |
| } |
| |
| /* XXX Still allocated: |
| - various static ad-hoc pointers to interned strings |
| - int and float free list blocks |
| - whatever various modules and libraries allocate |
| */ |
| |
| PyGrammar_RemoveAccelerators(&_PyParser_Grammar); |
| |
| /* Cleanup auto-thread-state */ |
| #ifdef WITH_THREAD |
| _PyGILState_Fini(); |
| #endif /* WITH_THREAD */ |
| |
| /* Delete current thread. After this, many C API calls become crashy. */ |
| PyThreadState_Swap(NULL); |
| |
| PyInterpreterState_Delete(interp); |
| |
| #ifdef Py_TRACE_REFS |
| /* Display addresses (& refcnts) of all objects still alive. |
| * An address can be used to find the repr of the object, printed |
| * above by _Py_PrintReferences. |
| */ |
| if (Py_GETENV("PYTHONDUMPREFS")) |
| _Py_PrintReferenceAddresses(stderr); |
| #endif /* Py_TRACE_REFS */ |
| #ifdef WITH_PYMALLOC |
| if (_PyMem_PymallocEnabled()) { |
| char *opt = Py_GETENV("PYTHONMALLOCSTATS"); |
| if (opt != NULL && *opt != '\0') |
| _PyObject_DebugMallocStats(stderr); |
| } |
| #endif |
| |
| call_ll_exitfuncs(); |
| return status; |
| } |
| |
| void |
| Py_Finalize(void) |
| { |
| Py_FinalizeEx(); |
| } |
| |
| /* Create and initialize a new interpreter and thread, and return the |
| new thread. This requires that Py_Initialize() has been called |
| first. |
| |
| Unsuccessful initialization yields a NULL pointer. Note that *no* |
| exception information is available even in this case -- the |
| exception information is held in the thread, and there is no |
| thread. |
| |
| Locking: as above. |
| |
| */ |
| |
| PyThreadState * |
| Py_NewInterpreter(void) |
| { |
| PyInterpreterState *interp; |
| PyThreadState *tstate, *save_tstate; |
| PyObject *bimod, *sysmod; |
| |
| if (!initialized) |
| Py_FatalError("Py_NewInterpreter: call Py_Initialize first"); |
| |
| #ifdef WITH_THREAD |
| /* Issue #10915, #15751: The GIL API doesn't work with multiple |
| interpreters: disable PyGILState_Check(). */ |
| _PyGILState_check_enabled = 0; |
| #endif |
| |
| interp = PyInterpreterState_New(); |
| if (interp == NULL) |
| return NULL; |
| |
| tstate = PyThreadState_New(interp); |
| if (tstate == NULL) { |
| PyInterpreterState_Delete(interp); |
| return NULL; |
| } |
| |
| save_tstate = PyThreadState_Swap(tstate); |
| |
| /* XXX The following is lax in error checking */ |
| |
| interp->modules = PyDict_New(); |
| |
| bimod = _PyImport_FindBuiltin("builtins"); |
| if (bimod != NULL) { |
| interp->builtins = PyModule_GetDict(bimod); |
| if (interp->builtins == NULL) |
| goto handle_error; |
| Py_INCREF(interp->builtins); |
| } |
| |
| /* initialize builtin exceptions */ |
| _PyExc_Init(bimod); |
| |
| sysmod = _PyImport_FindBuiltin("sys"); |
| if (bimod != NULL && sysmod != NULL) { |
| PyObject *pstderr; |
| |
| interp->sysdict = PyModule_GetDict(sysmod); |
| if (interp->sysdict == NULL) |
| goto handle_error; |
| Py_INCREF(interp->sysdict); |
| PySys_SetPath(Py_GetPath()); |
| PyDict_SetItemString(interp->sysdict, "modules", |
| interp->modules); |
| /* Set up a preliminary stderr printer until we have enough |
| infrastructure for the io module in place. */ |
| pstderr = PyFile_NewStdPrinter(fileno(stderr)); |
| if (pstderr == NULL) |
| Py_FatalError("Py_Initialize: can't set preliminary stderr"); |
| _PySys_SetObjectId(&PyId_stderr, pstderr); |
| PySys_SetObject("__stderr__", pstderr); |
| Py_DECREF(pstderr); |
| |
| _PyImportHooks_Init(); |
| |
| import_init(interp, sysmod); |
| |
| if (initfsencoding(interp) < 0) |
| goto handle_error; |
| |
| if (initstdio() < 0) |
| Py_FatalError( |
| "Py_Initialize: can't initialize sys standard streams"); |
| initmain(interp); |
| if (!Py_NoSiteFlag) |
| initsite(); |
| } |
| |
| if (!PyErr_Occurred()) |
| return tstate; |
| |
| handle_error: |
| /* Oops, it didn't work. Undo it all. */ |
| |
| PyErr_PrintEx(0); |
| PyThreadState_Clear(tstate); |
| PyThreadState_Swap(save_tstate); |
| PyThreadState_Delete(tstate); |
| PyInterpreterState_Delete(interp); |
| |
| return NULL; |
| } |
| |
| /* Delete an interpreter and its last thread. This requires that the |
| given thread state is current, that the thread has no remaining |
| frames, and that it is its interpreter's only remaining thread. |
| It is a fatal error to violate these constraints. |
| |
| (Py_FinalizeEx() doesn't have these constraints -- it zaps |
| everything, regardless.) |
| |
| Locking: as above. |
| |
| */ |
| |
| void |
| Py_EndInterpreter(PyThreadState *tstate) |
| { |
| PyInterpreterState *interp = tstate->interp; |
| |
| if (tstate != PyThreadState_GET()) |
| Py_FatalError("Py_EndInterpreter: thread is not current"); |
| if (tstate->frame != NULL) |
| Py_FatalError("Py_EndInterpreter: thread still has a frame"); |
| |
| wait_for_thread_shutdown(); |
| |
| if (tstate != interp->tstate_head || tstate->next != NULL) |
| Py_FatalError("Py_EndInterpreter: not the last thread"); |
| |
| PyImport_Cleanup(); |
| PyInterpreterState_Clear(interp); |
| PyThreadState_Swap(NULL); |
| PyInterpreterState_Delete(interp); |
| } |
| |
| #ifdef MS_WINDOWS |
| static wchar_t *progname = L"python"; |
| #else |
| static wchar_t *progname = L"python3"; |
| #endif |
| |
| void |
| Py_SetProgramName(wchar_t *pn) |
| { |
| if (pn && *pn) |
| progname = pn; |
| } |
| |
| wchar_t * |
| Py_GetProgramName(void) |
| { |
| return progname; |
| } |
| |
| static wchar_t *default_home = NULL; |
| static wchar_t env_home[MAXPATHLEN+1]; |
| |
| void |
| Py_SetPythonHome(wchar_t *home) |
| { |
| default_home = home; |
| } |
| |
| wchar_t * |
| Py_GetPythonHome(void) |
| { |
| wchar_t *home = default_home; |
| if (home == NULL && !Py_IgnoreEnvironmentFlag) { |
| char* chome = Py_GETENV("PYTHONHOME"); |
| if (chome) { |
| size_t size = Py_ARRAY_LENGTH(env_home); |
| size_t r = mbstowcs(env_home, chome, size); |
| if (r != (size_t)-1 && r < size) |
| home = env_home; |
| } |
| |
| } |
| return home; |
| } |
| |
| /* Create __main__ module */ |
| |
| static void |
| initmain(PyInterpreterState *interp) |
| { |
| PyObject *m, *d, *loader; |
| m = PyImport_AddModule("__main__"); |
| if (m == NULL) |
| Py_FatalError("can't create __main__ module"); |
| d = PyModule_GetDict(m); |
| if (PyDict_GetItemString(d, "__builtins__") == NULL) { |
| PyObject *bimod = PyImport_ImportModule("builtins"); |
| if (bimod == NULL) { |
| Py_FatalError("Failed to retrieve builtins module"); |
| } |
| if (PyDict_SetItemString(d, "__builtins__", bimod) < 0) { |
| Py_FatalError("Failed to initialize __main__.__builtins__"); |
| } |
| Py_DECREF(bimod); |
| } |
| /* Main is a little special - imp.is_builtin("__main__") will return |
| * False, but BuiltinImporter is still the most appropriate initial |
| * setting for its __loader__ attribute. A more suitable value will |
| * be set if __main__ gets further initialized later in the startup |
| * process. |
| */ |
| loader = PyDict_GetItemString(d, "__loader__"); |
| if (loader == NULL || loader == Py_None) { |
| PyObject *loader = PyObject_GetAttrString(interp->importlib, |
| "BuiltinImporter"); |
| if (loader == NULL) { |
| Py_FatalError("Failed to retrieve BuiltinImporter"); |
| } |
| if (PyDict_SetItemString(d, "__loader__", loader) < 0) { |
| Py_FatalError("Failed to initialize __main__.__loader__"); |
| } |
| Py_DECREF(loader); |
| } |
| } |
| |
| static int |
| initfsencoding(PyInterpreterState *interp) |
| { |
| PyObject *codec; |
| |
| #ifdef MS_WINDOWS |
| if (Py_LegacyWindowsFSEncodingFlag) |
| { |
| Py_FileSystemDefaultEncoding = "mbcs"; |
| Py_FileSystemDefaultEncodeErrors = "replace"; |
| } |
| else |
| { |
| Py_FileSystemDefaultEncoding = "utf-8"; |
| Py_FileSystemDefaultEncodeErrors = "surrogatepass"; |
| } |
| #else |
| if (Py_FileSystemDefaultEncoding == NULL) |
| { |
| Py_FileSystemDefaultEncoding = get_locale_encoding(); |
| if (Py_FileSystemDefaultEncoding == NULL) |
| Py_FatalError("Py_Initialize: Unable to get the locale encoding"); |
| |
| Py_HasFileSystemDefaultEncoding = 0; |
| interp->fscodec_initialized = 1; |
| return 0; |
| } |
| #endif |
| |
| /* the encoding is mbcs, utf-8 or ascii */ |
| codec = _PyCodec_Lookup(Py_FileSystemDefaultEncoding); |
| if (!codec) { |
| /* Such error can only occurs in critical situations: no more |
| * memory, import a module of the standard library failed, |
| * etc. */ |
| return -1; |
| } |
| Py_DECREF(codec); |
| interp->fscodec_initialized = 1; |
| return 0; |
| } |
| |
| /* Import the site module (not into __main__ though) */ |
| |
| static void |
| initsite(void) |
| { |
| PyObject *m; |
| m = PyImport_ImportModule("site"); |
| if (m == NULL) { |
| fprintf(stderr, "Failed to import the site module\n"); |
| PyErr_Print(); |
| Py_Finalize(); |
| exit(1); |
| } |
| else { |
| Py_DECREF(m); |
| } |
| } |
| |
| /* Check if a file descriptor is valid or not. |
| Return 0 if the file descriptor is invalid, return non-zero otherwise. */ |
| static int |
| is_valid_fd(int fd) |
| { |
| int fd2; |
| if (fd < 0 || !_PyVerify_fd(fd)) |
| return 0; |
| _Py_BEGIN_SUPPRESS_IPH |
| /* Prefer dup() over fstat(). fstat() can require input/output whereas |
| dup() doesn't, there is a low risk of EMFILE/ENFILE at Python |
| startup. */ |
| fd2 = dup(fd); |
| if (fd2 >= 0) |
| close(fd2); |
| _Py_END_SUPPRESS_IPH |
| return fd2 >= 0; |
| } |
| |
| /* returns Py_None if the fd is not valid */ |
| static PyObject* |
| create_stdio(PyObject* io, |
| int fd, int write_mode, const char* name, |
| const char* encoding, const char* errors) |
| { |
| PyObject *buf = NULL, *stream = NULL, *text = NULL, *raw = NULL, *res; |
| const char* mode; |
| const char* newline; |
| PyObject *line_buffering; |
| int buffering, isatty; |
| _Py_IDENTIFIER(open); |
| _Py_IDENTIFIER(isatty); |
| _Py_IDENTIFIER(TextIOWrapper); |
| _Py_IDENTIFIER(mode); |
| |
| if (!is_valid_fd(fd)) |
| Py_RETURN_NONE; |
| |
| /* stdin is always opened in buffered mode, first because it shouldn't |
| make a difference in common use cases, second because TextIOWrapper |
| depends on the presence of a read1() method which only exists on |
| buffered streams. |
| */ |
| if (Py_UnbufferedStdioFlag && write_mode) |
| buffering = 0; |
| else |
| buffering = -1; |
| if (write_mode) |
| mode = "wb"; |
| else |
| mode = "rb"; |
| buf = _PyObject_CallMethodId(io, &PyId_open, "isiOOOi", |
| fd, mode, buffering, |
| Py_None, Py_None, /* encoding, errors */ |
| Py_None, 0); /* newline, closefd */ |
| if (buf == NULL) |
| goto error; |
| |
| if (buffering) { |
| _Py_IDENTIFIER(raw); |
| raw = _PyObject_GetAttrId(buf, &PyId_raw); |
| if (raw == NULL) |
| goto error; |
| } |
| else { |
| raw = buf; |
| Py_INCREF(raw); |
| } |
| |
| text = PyUnicode_FromString(name); |
| if (text == NULL || _PyObject_SetAttrId(raw, &PyId_name, text) < 0) |
| goto error; |
| res = _PyObject_CallMethodId(raw, &PyId_isatty, NULL); |
| if (res == NULL) |
| goto error; |
| isatty = PyObject_IsTrue(res); |
| Py_DECREF(res); |
| if (isatty == -1) |
| goto error; |
| if (isatty || Py_UnbufferedStdioFlag) |
| line_buffering = Py_True; |
| else |
| line_buffering = Py_False; |
| |
| Py_CLEAR(raw); |
| Py_CLEAR(text); |
| |
| #ifdef MS_WINDOWS |
| /* sys.stdin: enable universal newline mode, translate "\r\n" and "\r" |
| newlines to "\n". |
| sys.stdout and sys.stderr: translate "\n" to "\r\n". */ |
| newline = NULL; |
| #else |
| /* sys.stdin: split lines at "\n". |
| sys.stdout and sys.stderr: don't translate newlines (use "\n"). */ |
| newline = "\n"; |
| #endif |
| |
| stream = _PyObject_CallMethodId(io, &PyId_TextIOWrapper, "OsssO", |
| buf, encoding, errors, |
| newline, line_buffering); |
| Py_CLEAR(buf); |
| if (stream == NULL) |
| goto error; |
| |
| if (write_mode) |
| mode = "w"; |
| else |
| mode = "r"; |
| text = PyUnicode_FromString(mode); |
| if (!text || _PyObject_SetAttrId(stream, &PyId_mode, text) < 0) |
| goto error; |
| Py_CLEAR(text); |
| return stream; |
| |
| error: |
| Py_XDECREF(buf); |
| Py_XDECREF(stream); |
| Py_XDECREF(text); |
| Py_XDECREF(raw); |
| |
| if (PyErr_ExceptionMatches(PyExc_OSError) && !is_valid_fd(fd)) { |
| /* Issue #24891: the file descriptor was closed after the first |
| is_valid_fd() check was called. Ignore the OSError and set the |
| stream to None. */ |
| PyErr_Clear(); |
| Py_RETURN_NONE; |
| } |
| return NULL; |
| } |
| |
| /* Initialize sys.stdin, stdout, stderr and builtins.open */ |
| static int |
| initstdio(void) |
| { |
| PyObject *iomod = NULL, *wrapper; |
| PyObject *bimod = NULL; |
| PyObject *m; |
| PyObject *std = NULL; |
| int status = 0, fd; |
| PyObject * encoding_attr; |
| char *pythonioencoding = NULL, *encoding, *errors; |
| |
| /* Hack to avoid a nasty recursion issue when Python is invoked |
| in verbose mode: pre-import the Latin-1 and UTF-8 codecs */ |
| if ((m = PyImport_ImportModule("encodings.utf_8")) == NULL) { |
| goto error; |
| } |
| Py_DECREF(m); |
| |
| if (!(m = PyImport_ImportModule("encodings.latin_1"))) { |
| goto error; |
| } |
| Py_DECREF(m); |
| |
| if (!(bimod = PyImport_ImportModule("builtins"))) { |
| goto error; |
| } |
| |
| if (!(iomod = PyImport_ImportModule("io"))) { |
| goto error; |
| } |
| if (!(wrapper = PyObject_GetAttrString(iomod, "OpenWrapper"))) { |
| goto error; |
| } |
| |
| /* Set builtins.open */ |
| if (PyObject_SetAttrString(bimod, "open", wrapper) == -1) { |
| Py_DECREF(wrapper); |
| goto error; |
| } |
| Py_DECREF(wrapper); |
| |
| encoding = _Py_StandardStreamEncoding; |
| errors = _Py_StandardStreamErrors; |
| if (!encoding || !errors) { |
| pythonioencoding = Py_GETENV("PYTHONIOENCODING"); |
| if (pythonioencoding) { |
| char *err; |
| pythonioencoding = _PyMem_Strdup(pythonioencoding); |
| if (pythonioencoding == NULL) { |
| PyErr_NoMemory(); |
| goto error; |
| } |
| err = strchr(pythonioencoding, ':'); |
| if (err) { |
| *err = '\0'; |
| err++; |
| if (*err && !errors) { |
| errors = err; |
| } |
| } |
| if (*pythonioencoding && !encoding) { |
| encoding = pythonioencoding; |
| } |
| } |
| if (!errors && !(pythonioencoding && *pythonioencoding)) { |
| /* When the LC_CTYPE locale is the POSIX locale ("C locale"), |
| stdin and stdout use the surrogateescape error handler by |
| default, instead of the strict error handler. */ |
| char *loc = setlocale(LC_CTYPE, NULL); |
| if (loc != NULL && strcmp(loc, "C") == 0) |
| errors = "surrogateescape"; |
| } |
| } |
| |
| /* Set sys.stdin */ |
| fd = fileno(stdin); |
| /* Under some conditions stdin, stdout and stderr may not be connected |
| * and fileno() may point to an invalid file descriptor. For example |
| * GUI apps don't have valid standard streams by default. |
| */ |
| std = create_stdio(iomod, fd, 0, "<stdin>", encoding, errors); |
| if (std == NULL) |
| goto error; |
| PySys_SetObject("__stdin__", std); |
| _PySys_SetObjectId(&PyId_stdin, std); |
| Py_DECREF(std); |
| |
| /* Set sys.stdout */ |
| fd = fileno(stdout); |
| std = create_stdio(iomod, fd, 1, "<stdout>", encoding, errors); |
| if (std == NULL) |
| goto error; |
| PySys_SetObject("__stdout__", std); |
| _PySys_SetObjectId(&PyId_stdout, std); |
| Py_DECREF(std); |
| |
| #if 1 /* Disable this if you have trouble debugging bootstrap stuff */ |
| /* Set sys.stderr, replaces the preliminary stderr */ |
| fd = fileno(stderr); |
| std = create_stdio(iomod, fd, 1, "<stderr>", encoding, "backslashreplace"); |
| if (std == NULL) |
| goto error; |
| |
| /* Same as hack above, pre-import stderr's codec to avoid recursion |
| when import.c tries to write to stderr in verbose mode. */ |
| encoding_attr = PyObject_GetAttrString(std, "encoding"); |
| if (encoding_attr != NULL) { |
| const char * std_encoding; |
| std_encoding = _PyUnicode_AsString(encoding_attr); |
| if (std_encoding != NULL) { |
| PyObject *codec_info = _PyCodec_Lookup(std_encoding); |
| Py_XDECREF(codec_info); |
| } |
| Py_DECREF(encoding_attr); |
| } |
| PyErr_Clear(); /* Not a fatal error if codec isn't available */ |
| |
| if (PySys_SetObject("__stderr__", std) < 0) { |
| Py_DECREF(std); |
| goto error; |
| } |
| if (_PySys_SetObjectId(&PyId_stderr, std) < 0) { |
| Py_DECREF(std); |
| goto error; |
| } |
| Py_DECREF(std); |
| #endif |
| |
| if (0) { |
| error: |
| status = -1; |
| } |
| |
| /* We won't need them anymore. */ |
| if (_Py_StandardStreamEncoding) { |
| PyMem_RawFree(_Py_StandardStreamEncoding); |
| _Py_StandardStreamEncoding = NULL; |
| } |
| if (_Py_StandardStreamErrors) { |
| PyMem_RawFree(_Py_StandardStreamErrors); |
| _Py_StandardStreamErrors = NULL; |
| } |
| PyMem_Free(pythonioencoding); |
| Py_XDECREF(bimod); |
| Py_XDECREF(iomod); |
| return status; |
| } |
| |
| |
| static void |
| _Py_FatalError_DumpTracebacks(int fd) |
| { |
| fputc('\n', stderr); |
| fflush(stderr); |
| |
| /* display the current Python stack */ |
| _Py_DumpTracebackThreads(fd, NULL, NULL); |
| } |
| |
| /* Print the current exception (if an exception is set) with its traceback, |
| or display the current Python stack. |
| |
| Don't call PyErr_PrintEx() and the except hook, because Py_FatalError() is |
| called on catastrophic cases. |
| |
| Return 1 if the traceback was displayed, 0 otherwise. */ |
| |
| static int |
| _Py_FatalError_PrintExc(int fd) |
| { |
| PyObject *ferr, *res; |
| PyObject *exception, *v, *tb; |
| int has_tb; |
| |
| if (PyThreadState_GET() == NULL) { |
| /* The GIL is released: trying to acquire it is likely to deadlock, |
| just give up. */ |
| return 0; |
| } |
| |
| PyErr_Fetch(&exception, &v, &tb); |
| if (exception == NULL) { |
| /* No current exception */ |
| return 0; |
| } |
| |
| ferr = _PySys_GetObjectId(&PyId_stderr); |
| if (ferr == NULL || ferr == Py_None) { |
| /* sys.stderr is not set yet or set to None, |
| no need to try to display the exception */ |
| return 0; |
| } |
| |
| PyErr_NormalizeException(&exception, &v, &tb); |
| if (tb == NULL) { |
| tb = Py_None; |
| Py_INCREF(tb); |
| } |
| PyException_SetTraceback(v, tb); |
| if (exception == NULL) { |
| /* PyErr_NormalizeException() failed */ |
| return 0; |
| } |
| |
| has_tb = (tb != Py_None); |
| PyErr_Display(exception, v, tb); |
| Py_XDECREF(exception); |
| Py_XDECREF(v); |
| Py_XDECREF(tb); |
| |
| /* sys.stderr may be buffered: call sys.stderr.flush() */ |
| res = _PyObject_CallMethodId(ferr, &PyId_flush, NULL); |
| if (res == NULL) |
| PyErr_Clear(); |
| else |
| Py_DECREF(res); |
| |
| return has_tb; |
| } |
| |
| /* Print fatal error message and abort */ |
| |
| void |
| Py_FatalError(const char *msg) |
| { |
| const int fd = fileno(stderr); |
| static int reentrant = 0; |
| #ifdef MS_WINDOWS |
| size_t len; |
| WCHAR* buffer; |
| size_t i; |
| #endif |
| |
| if (reentrant) { |
| /* Py_FatalError() caused a second fatal error. |
| Example: flush_std_files() raises a recursion error. */ |
| goto exit; |
| } |
| reentrant = 1; |
| |
| fprintf(stderr, "Fatal Python error: %s\n", msg); |
| fflush(stderr); /* it helps in Windows debug build */ |
| |
| /* Print the exception (if an exception is set) with its traceback, |
| * or display the current Python stack. */ |
| if (!_Py_FatalError_PrintExc(fd)) |
| _Py_FatalError_DumpTracebacks(fd); |
| |
| /* The main purpose of faulthandler is to display the traceback. We already |
| * did our best to display it. So faulthandler can now be disabled. |
| * (Don't trigger it on abort().) */ |
| _PyFaulthandler_Fini(); |
| |
| /* Check if the current Python thread hold the GIL */ |
| if (PyThreadState_GET() != NULL) { |
| /* Flush sys.stdout and sys.stderr */ |
| flush_std_files(); |
| } |
| |
| #ifdef MS_WINDOWS |
| len = strlen(msg); |
| |
| /* Convert the message to wchar_t. This uses a simple one-to-one |
| conversion, assuming that the this error message actually uses ASCII |
| only. If this ceases to be true, we will have to convert. */ |
| buffer = alloca( (len+1) * (sizeof *buffer)); |
| for( i=0; i<=len; ++i) |
| buffer[i] = msg[i]; |
| OutputDebugStringW(L"Fatal Python error: "); |
| OutputDebugStringW(buffer); |
| OutputDebugStringW(L"\n"); |
| #endif /* MS_WINDOWS */ |
| |
| exit: |
| #if defined(MS_WINDOWS) && defined(_DEBUG) |
| DebugBreak(); |
| #endif |
| abort(); |
| } |
| |
| /* Clean up and exit */ |
| |
| #ifdef WITH_THREAD |
| # include "pythread.h" |
| #endif |
| |
| static void (*pyexitfunc)(void) = NULL; |
| /* For the atexit module. */ |
| void _Py_PyAtExit(void (*func)(void)) |
| { |
| pyexitfunc = func; |
| } |
| |
| static void |
| call_py_exitfuncs(void) |
| { |
| if (pyexitfunc == NULL) |
| return; |
| |
| (*pyexitfunc)(); |
| PyErr_Clear(); |
| } |
| |
| /* Wait until threading._shutdown completes, provided |
| the threading module was imported in the first place. |
| The shutdown routine will wait until all non-daemon |
| "threading" threads have completed. */ |
| static void |
| wait_for_thread_shutdown(void) |
| { |
| #ifdef WITH_THREAD |
| _Py_IDENTIFIER(_shutdown); |
| PyObject *result; |
| PyThreadState *tstate = PyThreadState_GET(); |
| PyObject *threading = PyMapping_GetItemString(tstate->interp->modules, |
| "threading"); |
| if (threading == NULL) { |
| /* threading not imported */ |
| PyErr_Clear(); |
| return; |
| } |
| result = _PyObject_CallMethodId(threading, &PyId__shutdown, NULL); |
| if (result == NULL) { |
| PyErr_WriteUnraisable(threading); |
| } |
| else { |
| Py_DECREF(result); |
| } |
| Py_DECREF(threading); |
| #endif |
| } |
| |
| #define NEXITFUNCS 32 |
| static void (*exitfuncs[NEXITFUNCS])(void); |
| static int nexitfuncs = 0; |
| |
| int Py_AtExit(void (*func)(void)) |
| { |
| if (nexitfuncs >= NEXITFUNCS) |
| return -1; |
| exitfuncs[nexitfuncs++] = func; |
| return 0; |
| } |
| |
| static void |
| call_ll_exitfuncs(void) |
| { |
| while (nexitfuncs > 0) |
| (*exitfuncs[--nexitfuncs])(); |
| |
| fflush(stdout); |
| fflush(stderr); |
| } |
| |
| void |
| Py_Exit(int sts) |
| { |
| if (Py_FinalizeEx() < 0) { |
| sts = 120; |
| } |
| |
| exit(sts); |
| } |
| |
| static void |
| initsigs(void) |
| { |
| #ifdef SIGPIPE |
| PyOS_setsig(SIGPIPE, SIG_IGN); |
| #endif |
| #ifdef SIGXFZ |
| PyOS_setsig(SIGXFZ, SIG_IGN); |
| #endif |
| #ifdef SIGXFSZ |
| PyOS_setsig(SIGXFSZ, SIG_IGN); |
| #endif |
| PyOS_InitInterrupts(); /* May imply initsignal() */ |
| if (PyErr_Occurred()) { |
| Py_FatalError("Py_Initialize: can't import signal"); |
| } |
| } |
| |
| |
| /* Restore signals that the interpreter has called SIG_IGN on to SIG_DFL. |
| * |
| * All of the code in this function must only use async-signal-safe functions, |
| * listed at `man 7 signal` or |
| * http://www.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html. |
| */ |
| void |
| _Py_RestoreSignals(void) |
| { |
| #ifdef SIGPIPE |
| PyOS_setsig(SIGPIPE, SIG_DFL); |
| #endif |
| #ifdef SIGXFZ |
| PyOS_setsig(SIGXFZ, SIG_DFL); |
| #endif |
| #ifdef SIGXFSZ |
| PyOS_setsig(SIGXFSZ, SIG_DFL); |
| #endif |
| } |
| |
| |
| /* |
| * The file descriptor fd is considered ``interactive'' if either |
| * a) isatty(fd) is TRUE, or |
| * b) the -i flag was given, and the filename associated with |
| * the descriptor is NULL or "<stdin>" or "???". |
| */ |
| int |
| Py_FdIsInteractive(FILE *fp, const char *filename) |
| { |
| if (isatty((int)fileno(fp))) |
| return 1; |
| if (!Py_InteractiveFlag) |
| return 0; |
| return (filename == NULL) || |
| (strcmp(filename, "<stdin>") == 0) || |
| (strcmp(filename, "???") == 0); |
| } |
| |
| |
| /* Wrappers around sigaction() or signal(). */ |
| |
| PyOS_sighandler_t |
| PyOS_getsig(int sig) |
| { |
| #ifdef HAVE_SIGACTION |
| struct sigaction context; |
| if (sigaction(sig, NULL, &context) == -1) |
| return SIG_ERR; |
| return context.sa_handler; |
| #else |
| PyOS_sighandler_t handler; |
| /* Special signal handling for the secure CRT in Visual Studio 2005 */ |
| #if defined(_MSC_VER) && _MSC_VER >= 1400 |
| switch (sig) { |
| /* Only these signals are valid */ |
| case SIGINT: |
| case SIGILL: |
| case SIGFPE: |
| case SIGSEGV: |
| case SIGTERM: |
| case SIGBREAK: |
| case SIGABRT: |
| break; |
| /* Don't call signal() with other values or it will assert */ |
| default: |
| return SIG_ERR; |
| } |
| #endif /* _MSC_VER && _MSC_VER >= 1400 */ |
| handler = signal(sig, SIG_IGN); |
| if (handler != SIG_ERR) |
| signal(sig, handler); |
| return handler; |
| #endif |
| } |
| |
| /* |
| * All of the code in this function must only use async-signal-safe functions, |
| * listed at `man 7 signal` or |
| * http://www.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html. |
| */ |
| PyOS_sighandler_t |
| PyOS_setsig(int sig, PyOS_sighandler_t handler) |
| { |
| #ifdef HAVE_SIGACTION |
| /* Some code in Modules/signalmodule.c depends on sigaction() being |
| * used here if HAVE_SIGACTION is defined. Fix that if this code |
| * changes to invalidate that assumption. |
| */ |
| struct sigaction context, ocontext; |
| context.sa_handler = handler; |
| sigemptyset(&context.sa_mask); |
| context.sa_flags = 0; |
| if (sigaction(sig, &context, &ocontext) == -1) |
| return SIG_ERR; |
| return ocontext.sa_handler; |
| #else |
| PyOS_sighandler_t oldhandler; |
| oldhandler = signal(sig, handler); |
| #ifdef HAVE_SIGINTERRUPT |
| siginterrupt(sig, 1); |
| #endif |
| return oldhandler; |
| #endif |
| } |
| |
| #ifdef __cplusplus |
| } |
| #endif |