1 /* Python interpreter top-level routines, including init/exit */ 2 3 #include "Python.h" 4 5 #include "Python-ast.h" 6 #undef Yield /* undefine macro conflicting with winbase.h */ 7 #include "internal/context.h" 8 #include "internal/hamt.h" 9 #include "internal/pystate.h" 10 #include "grammar.h" 11 #include "node.h" 12 #include "token.h" 13 #include "parsetok.h" 14 #include "errcode.h" 15 #include "code.h" 16 #include "symtable.h" 17 #include "ast.h" 18 #include "marshal.h" 19 #include "osdefs.h" 20 #include <locale.h> 21 22 #ifdef HAVE_SIGNAL_H 23 #include <signal.h> 24 #endif 25 26 #ifdef MS_WINDOWS 27 #include "malloc.h" /* for alloca */ 28 #endif 29 30 #ifdef HAVE_LANGINFO_H 31 #include <langinfo.h> 32 #endif 33 34 #ifdef MS_WINDOWS 35 #undef BYTE 36 #include "windows.h" 37 38 extern PyTypeObject PyWindowsConsoleIO_Type; 39 #define PyWindowsConsoleIO_Check(op) (PyObject_TypeCheck((op), &PyWindowsConsoleIO_Type)) 40 #endif 41 42 _Py_IDENTIFIER(flush); 43 _Py_IDENTIFIER(name); 44 _Py_IDENTIFIER(stdin); 45 _Py_IDENTIFIER(stdout); 46 _Py_IDENTIFIER(stderr); 47 _Py_IDENTIFIER(threading); 48 49 #ifdef __cplusplus 50 extern "C" { 51 #endif 52 53 extern grammar _PyParser_Grammar; /* From graminit.c */ 54 55 /* Forward */ 56 static _PyInitError add_main_module(PyInterpreterState *interp); 57 static _PyInitError initfsencoding(PyInterpreterState *interp); 58 static _PyInitError initsite(void); 59 static _PyInitError init_sys_streams(PyInterpreterState *interp); 60 static _PyInitError initsigs(void); 61 static void call_py_exitfuncs(PyInterpreterState *); 62 static void wait_for_thread_shutdown(void); 63 static void call_ll_exitfuncs(void); 64 extern int _PyUnicode_Init(void); 65 extern int _PyStructSequence_Init(void); 66 extern void _PyUnicode_Fini(void); 67 extern int _PyLong_Init(void); 68 extern void PyLong_Fini(void); 69 extern _PyInitError _PyFaulthandler_Init(int enable); 70 extern void _PyFaulthandler_Fini(void); 71 extern void _PyHash_Fini(void); 72 extern int _PyTraceMalloc_Init(int enable); 73 extern int _PyTraceMalloc_Fini(void); 74 extern void _Py_ReadyTypes(void); 75 76 extern void _PyGILState_Init(PyInterpreterState *, PyThreadState *); 77 extern void _PyGILState_Fini(void); 78 79 _PyRuntimeState _PyRuntime = _PyRuntimeState_INIT; 80 81 _PyInitError 82 _PyRuntime_Initialize(void) 83 { 84 /* XXX We only initialize once in the process, which aligns with 85 the static initialization of the former globals now found in 86 _PyRuntime. However, _PyRuntime *should* be initialized with 87 every Py_Initialize() call, but doing so breaks the runtime. 88 This is because the runtime state is not properly finalized 89 currently. */ 90 static int initialized = 0; 91 if (initialized) { 92 return _Py_INIT_OK(); 93 } 94 initialized = 1; 95 96 return _PyRuntimeState_Init(&_PyRuntime); 97 } 98 99 void 100 _PyRuntime_Finalize(void) 101 { 102 _PyRuntimeState_Fini(&_PyRuntime); 103 } 104 105 int 106 _Py_IsFinalizing(void) 107 { 108 return _PyRuntime.finalizing != NULL; 109 } 110 111 /* Global configuration variable declarations are in pydebug.h */ 112 /* XXX (ncoghlan): move those declarations to pylifecycle.h? */ 113 int Py_DebugFlag = 0; /* Needed by parser.c */ 114 int Py_VerboseFlag = 0; /* Needed by import.c */ 115 int Py_QuietFlag = 0; /* Needed by sysmodule.c */ 116 int Py_InteractiveFlag = 0; /* Needed by Py_FdIsInteractive() below */ 117 int Py_InspectFlag = 0; /* Needed to determine whether to exit at SystemExit */ 118 int Py_OptimizeFlag = 0; /* Needed by compile.c */ 119 int Py_NoSiteFlag = 0; /* Suppress 'import site' */ 120 int Py_BytesWarningFlag = 0; /* Warn on str(bytes) and str(buffer) */ 121 int Py_FrozenFlag = 0; /* Needed by getpath.c */ 122 int Py_IgnoreEnvironmentFlag = 0; /* e.g. PYTHONPATH, PYTHONHOME */ 123 int Py_DontWriteBytecodeFlag = 0; /* Suppress writing bytecode files (*.pyc) */ 124 int Py_NoUserSiteDirectory = 0; /* for -s and site.py */ 125 int Py_UnbufferedStdioFlag = 0; /* Unbuffered binary std{in,out,err} */ 126 int Py_HashRandomizationFlag = 0; /* for -R and PYTHONHASHSEED */ 127 int Py_IsolatedFlag = 0; /* for -I, isolate from user's env */ 128 #ifdef MS_WINDOWS 129 int Py_LegacyWindowsFSEncodingFlag = 0; /* Uses mbcs instead of utf-8 */ 130 int Py_LegacyWindowsStdioFlag = 0; /* Uses FileIO instead of WindowsConsoleIO */ 131 #endif 132 133 /* Hack to force loading of object files */ 134 int (*_PyOS_mystrnicmp_hack)(const char *, const char *, Py_ssize_t) = \ 135 PyOS_mystrnicmp; /* Python/pystrcmp.o */ 136 137 /* PyModule_GetWarningsModule is no longer necessary as of 2.6 138 since _warnings is builtin. This API should not be used. */ 139 PyObject * 140 PyModule_GetWarningsModule(void) 141 { 142 return PyImport_ImportModule("warnings"); 143 } 144 145 146 /* APIs to access the initialization flags 147 * 148 * Can be called prior to Py_Initialize. 149 */ 150 151 int 152 _Py_IsCoreInitialized(void) 153 { 154 return _PyRuntime.core_initialized; 155 } 156 157 int 158 Py_IsInitialized(void) 159 { 160 return _PyRuntime.initialized; 161 } 162 163 /* Helper to allow an embedding application to override the normal 164 * mechanism that attempts to figure out an appropriate IO encoding 165 */ 166 167 static char *_Py_StandardStreamEncoding = NULL; 168 static char *_Py_StandardStreamErrors = NULL; 169 170 int 171 Py_SetStandardStreamEncoding(const char *encoding, const char *errors) 172 { 173 if (Py_IsInitialized()) { 174 /* This is too late to have any effect */ 175 return -1; 176 } 177 178 int res = 0; 179 180 /* Py_SetStandardStreamEncoding() can be called before Py_Initialize(), 181 but Py_Initialize() can change the allocator. Use a known allocator 182 to be able to release the memory later. */ 183 PyMemAllocatorEx old_alloc; 184 _PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc); 185 186 /* Can't call PyErr_NoMemory() on errors, as Python hasn't been 187 * initialised yet. 188 * 189 * However, the raw memory allocators are initialised appropriately 190 * as C static variables, so _PyMem_RawStrdup is OK even though 191 * Py_Initialize hasn't been called yet. 192 */ 193 if (encoding) { 194 _Py_StandardStreamEncoding = _PyMem_RawStrdup(encoding); 195 if (!_Py_StandardStreamEncoding) { 196 res = -2; 197 goto done; 198 } 199 } 200 if (errors) { 201 _Py_StandardStreamErrors = _PyMem_RawStrdup(errors); 202 if (!_Py_StandardStreamErrors) { 203 if (_Py_StandardStreamEncoding) { 204 PyMem_RawFree(_Py_StandardStreamEncoding); 205 } 206 res = -3; 207 goto done; 208 } 209 } 210 #ifdef MS_WINDOWS 211 if (_Py_StandardStreamEncoding) { 212 /* Overriding the stream encoding implies legacy streams */ 213 Py_LegacyWindowsStdioFlag = 1; 214 } 215 #endif 216 217 done: 218 PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc); 219 220 return res; 221 } 222 223 224 /* Global initializations. Can be undone by Py_FinalizeEx(). Don't 225 call this twice without an intervening Py_FinalizeEx() call. When 226 initializations fail, a fatal error is issued and the function does 227 not return. On return, the first thread and interpreter state have 228 been created. 229 230 Locking: you must hold the interpreter lock while calling this. 231 (If the lock has not yet been initialized, that's equivalent to 232 having the lock, but you cannot use multiple threads.) 233 234 */ 235 236 static char* 237 get_codec_name(const char *encoding) 238 { 239 const char *name_utf8; 240 char *name_str; 241 PyObject *codec, *name = NULL; 242 243 codec = _PyCodec_Lookup(encoding); 244 if (!codec) 245 goto error; 246 247 name = _PyObject_GetAttrId(codec, &PyId_name); 248 Py_CLEAR(codec); 249 if (!name) 250 goto error; 251 252 name_utf8 = PyUnicode_AsUTF8(name); 253 if (name_utf8 == NULL) 254 goto error; 255 name_str = _PyMem_RawStrdup(name_utf8); 256 Py_DECREF(name); 257 if (name_str == NULL) { 258 PyErr_NoMemory(); 259 return NULL; 260 } 261 return name_str; 262 263 error: 264 Py_XDECREF(codec); 265 Py_XDECREF(name); 266 return NULL; 267 } 268 269 static char* 270 get_locale_encoding(void) 271 { 272 #if defined(HAVE_LANGINFO_H) && defined(CODESET) 273 char* codeset = nl_langinfo(CODESET); 274 if (!codeset || codeset[0] == '\0') { 275 PyErr_SetString(PyExc_ValueError, "CODESET is not set or empty"); 276 return NULL; 277 } 278 return get_codec_name(codeset); 279 #elif defined(__ANDROID__) 280 return get_codec_name("UTF-8"); 281 #else 282 PyErr_SetNone(PyExc_NotImplementedError); 283 return NULL; 284 #endif 285 } 286 287 static _PyInitError 288 initimport(PyInterpreterState *interp, PyObject *sysmod) 289 { 290 PyObject *importlib; 291 PyObject *impmod; 292 PyObject *value; 293 _PyInitError err; 294 295 /* Import _importlib through its frozen version, _frozen_importlib. */ 296 if (PyImport_ImportFrozenModule("_frozen_importlib") <= 0) { 297 return _Py_INIT_ERR("can't import _frozen_importlib"); 298 } 299 else if (Py_VerboseFlag) { 300 PySys_FormatStderr("import _frozen_importlib # frozen\n"); 301 } 302 importlib = PyImport_AddModule("_frozen_importlib"); 303 if (importlib == NULL) { 304 return _Py_INIT_ERR("couldn't get _frozen_importlib from sys.modules"); 305 } 306 interp->importlib = importlib; 307 Py_INCREF(interp->importlib); 308 309 interp->import_func = PyDict_GetItemString(interp->builtins, "__import__"); 310 if (interp->import_func == NULL) 311 return _Py_INIT_ERR("__import__ not found"); 312 Py_INCREF(interp->import_func); 313 314 /* Import the _imp module */ 315 impmod = PyInit__imp(); 316 if (impmod == NULL) { 317 return _Py_INIT_ERR("can't import _imp"); 318 } 319 else if (Py_VerboseFlag) { 320 PySys_FormatStderr("import _imp # builtin\n"); 321 } 322 if (_PyImport_SetModuleString("_imp", impmod) < 0) { 323 return _Py_INIT_ERR("can't save _imp to sys.modules"); 324 } 325 326 /* Install importlib as the implementation of import */ 327 value = PyObject_CallMethod(importlib, "_install", "OO", sysmod, impmod); 328 if (value == NULL) { 329 PyErr_Print(); 330 return _Py_INIT_ERR("importlib install failed"); 331 } 332 Py_DECREF(value); 333 Py_DECREF(impmod); 334 335 err = _PyImportZip_Init(); 336 if (_Py_INIT_FAILED(err)) { 337 return err; 338 } 339 340 return _Py_INIT_OK(); 341 } 342 343 static _PyInitError 344 initexternalimport(PyInterpreterState *interp) 345 { 346 PyObject *value; 347 value = PyObject_CallMethod(interp->importlib, 348 "_install_external_importers", ""); 349 if (value == NULL) { 350 PyErr_Print(); 351 return _Py_INIT_ERR("external importer setup failed"); 352 } 353 Py_DECREF(value); 354 return _Py_INIT_OK(); 355 } 356 357 /* Helper functions to better handle the legacy C locale 358 * 359 * The legacy C locale assumes ASCII as the default text encoding, which 360 * causes problems not only for the CPython runtime, but also other 361 * components like GNU readline. 362 * 363 * Accordingly, when the CLI detects it, it attempts to coerce it to a 364 * more capable UTF-8 based alternative as follows: 365 * 366 * if (_Py_LegacyLocaleDetected()) { 367 * _Py_CoerceLegacyLocale(); 368 * } 369 * 370 * See the documentation of the PYTHONCOERCECLOCALE setting for more details. 371 * 372 * Locale coercion also impacts the default error handler for the standard 373 * streams: while the usual default is "strict", the default for the legacy 374 * C locale and for any of the coercion target locales is "surrogateescape". 375 */ 376 377 int 378 _Py_LegacyLocaleDetected(void) 379 { 380 #ifndef MS_WINDOWS 381 /* On non-Windows systems, the C locale is considered a legacy locale */ 382 /* XXX (ncoghlan): some platforms (notably Mac OS X) don't appear to treat 383 * the POSIX locale as a simple alias for the C locale, so 384 * we may also want to check for that explicitly. 385 */ 386 const char *ctype_loc = setlocale(LC_CTYPE, NULL); 387 return ctype_loc != NULL && strcmp(ctype_loc, "C") == 0; 388 #else 389 /* Windows uses code pages instead of locales, so no locale is legacy */ 390 return 0; 391 #endif 392 } 393 394 static const char *_C_LOCALE_WARNING = 395 "Python runtime initialized with LC_CTYPE=C (a locale with default ASCII " 396 "encoding), which may cause Unicode compatibility problems. Using C.UTF-8, " 397 "C.utf8, or UTF-8 (if available) as alternative Unicode-compatible " 398 "locales is recommended.\n"; 399 400 static void 401 _emit_stderr_warning_for_legacy_locale(const _PyCoreConfig *core_config) 402 { 403 if (core_config->coerce_c_locale_warn) { 404 if (_Py_LegacyLocaleDetected()) { 405 fprintf(stderr, "%s", _C_LOCALE_WARNING); 406 } 407 } 408 } 409 410 typedef struct _CandidateLocale { 411 const char *locale_name; /* The locale to try as a coercion target */ 412 } _LocaleCoercionTarget; 413 414 static _LocaleCoercionTarget _TARGET_LOCALES[] = { 415 {"C.UTF-8"}, 416 {"C.utf8"}, 417 {"UTF-8"}, 418 {NULL} 419 }; 420 421 static const char * 422 get_default_standard_stream_error_handler(void) 423 { 424 const char *ctype_loc = setlocale(LC_CTYPE, NULL); 425 if (ctype_loc != NULL) { 426 /* surrogateescape is the default in the legacy C and POSIX locales */ 427 if (strcmp(ctype_loc, "C") == 0 || strcmp(ctype_loc, "POSIX") == 0) { 428 return "surrogateescape"; 429 } 430 431 #ifdef PY_COERCE_C_LOCALE 432 /* surrogateescape is the default in locale coercion target locales */ 433 const _LocaleCoercionTarget *target = NULL; 434 for (target = _TARGET_LOCALES; target->locale_name; target++) { 435 if (strcmp(ctype_loc, target->locale_name) == 0) { 436 return "surrogateescape"; 437 } 438 } 439 #endif 440 } 441 442 /* Otherwise return NULL to request the typical default error handler */ 443 return "strict"; 444 } 445 446 #ifdef PY_COERCE_C_LOCALE 447 static const char C_LOCALE_COERCION_WARNING[] = 448 "Python detected LC_CTYPE=C: LC_CTYPE coerced to %.20s (set another locale " 449 "or PYTHONCOERCECLOCALE=0 to disable this locale coercion behavior).\n"; 450 451 static void 452 _coerce_default_locale_settings(const _PyCoreConfig *config, const _LocaleCoercionTarget *target) 453 { 454 const char *newloc = target->locale_name; 455 456 /* Reset locale back to currently configured defaults */ 457 _Py_SetLocaleFromEnv(LC_ALL); 458 459 /* Set the relevant locale environment variable */ 460 if (setenv("LC_CTYPE", newloc, 1)) { 461 fprintf(stderr, 462 "Error setting LC_CTYPE, skipping C locale coercion\n"); 463 return; 464 } 465 if (config->coerce_c_locale_warn) { 466 fprintf(stderr, C_LOCALE_COERCION_WARNING, newloc); 467 } 468 469 /* Reconfigure with the overridden environment variables */ 470 _Py_SetLocaleFromEnv(LC_ALL); 471 } 472 #endif 473 474 void 475 _Py_CoerceLegacyLocale(const _PyCoreConfig *config) 476 { 477 #ifdef PY_COERCE_C_LOCALE 478 char *oldloc = NULL; 479 480 oldloc = _PyMem_RawStrdup(setlocale(LC_CTYPE, NULL)); 481 if (oldloc == NULL) { 482 return; 483 } 484 485 const char *locale_override = getenv("LC_ALL"); 486 if (locale_override == NULL || *locale_override == '\0') { 487 /* LC_ALL is also not set (or is set to an empty string) */ 488 const _LocaleCoercionTarget *target = NULL; 489 for (target = _TARGET_LOCALES; target->locale_name; target++) { 490 const char *new_locale = setlocale(LC_CTYPE, 491 target->locale_name); 492 if (new_locale != NULL) { 493 #if !defined(__APPLE__) && !defined(__ANDROID__) && \ 494 defined(HAVE_LANGINFO_H) && defined(CODESET) 495 /* Also ensure that nl_langinfo works in this locale */ 496 char *codeset = nl_langinfo(CODESET); 497 if (!codeset || *codeset == '\0') { 498 /* CODESET is not set or empty, so skip coercion */ 499 new_locale = NULL; 500 _Py_SetLocaleFromEnv(LC_CTYPE); 501 continue; 502 } 503 #endif 504 /* Successfully configured locale, so make it the default */ 505 _coerce_default_locale_settings(config, target); 506 goto done; 507 } 508 } 509 } 510 /* No C locale warning here, as Py_Initialize will emit one later */ 511 512 setlocale(LC_CTYPE, oldloc); 513 514 done: 515 PyMem_RawFree(oldloc); 516 #endif 517 } 518 519 /* _Py_SetLocaleFromEnv() is a wrapper around setlocale(category, "") to 520 * isolate the idiosyncrasies of different libc implementations. It reads the 521 * appropriate environment variable and uses its value to select the locale for 522 * 'category'. */ 523 char * 524 _Py_SetLocaleFromEnv(int category) 525 { 526 char *res; 527 #ifdef __ANDROID__ 528 const char *locale; 529 const char **pvar; 530 #ifdef PY_COERCE_C_LOCALE 531 const char *coerce_c_locale; 532 #endif 533 const char *utf8_locale = "C.UTF-8"; 534 const char *env_var_set[] = { 535 "LC_ALL", 536 "LC_CTYPE", 537 "LANG", 538 NULL, 539 }; 540 541 /* Android setlocale(category, "") doesn't check the environment variables 542 * and incorrectly sets the "C" locale at API 24 and older APIs. We only 543 * check the environment variables listed in env_var_set. */ 544 for (pvar=env_var_set; *pvar; pvar++) { 545 locale = getenv(*pvar); 546 if (locale != NULL && *locale != '\0') { 547 if (strcmp(locale, utf8_locale) == 0 || 548 strcmp(locale, "en_US.UTF-8") == 0) { 549 return setlocale(category, utf8_locale); 550 } 551 return setlocale(category, "C"); 552 } 553 } 554 555 /* Android uses UTF-8, so explicitly set the locale to C.UTF-8 if none of 556 * LC_ALL, LC_CTYPE, or LANG is set to a non-empty string. 557 * Quote from POSIX section "8.2 Internationalization Variables": 558 * "4. If the LANG environment variable is not set or is set to the empty 559 * string, the implementation-defined default locale shall be used." */ 560 561 #ifdef PY_COERCE_C_LOCALE 562 coerce_c_locale = getenv("PYTHONCOERCECLOCALE"); 563 if (coerce_c_locale == NULL || strcmp(coerce_c_locale, "0") != 0) { 564 /* Some other ported code may check the environment variables (e.g. in 565 * extension modules), so we make sure that they match the locale 566 * configuration */ 567 if (setenv("LC_CTYPE", utf8_locale, 1)) { 568 fprintf(stderr, "Warning: failed setting the LC_CTYPE " 569 "environment variable to %s\n", utf8_locale); 570 } 571 } 572 #endif 573 res = setlocale(category, utf8_locale); 574 #else /* !defined(__ANDROID__) */ 575 res = setlocale(category, ""); 576 #endif 577 _Py_ResetForceASCII(); 578 return res; 579 } 580 581 582 /* Global initializations. Can be undone by Py_Finalize(). Don't 583 call this twice without an intervening Py_Finalize() call. 584 585 Every call to Py_InitializeCore, Py_Initialize or Py_InitializeEx 586 must have a corresponding call to Py_Finalize. 587 588 Locking: you must hold the interpreter lock while calling these APIs. 589 (If the lock has not yet been initialized, that's equivalent to 590 having the lock, but you cannot use multiple threads.) 591 592 */ 593 594 static _PyInitError 595 _Py_Initialize_ReconfigureCore(PyInterpreterState *interp, 596 const _PyCoreConfig *core_config) 597 { 598 if (core_config->allocator != NULL) { 599 const char *allocator = _PyMem_GetAllocatorsName(); 600 if (allocator == NULL || strcmp(core_config->allocator, allocator) != 0) { 601 return _Py_INIT_USER_ERR("cannot modify memory allocator " 602 "after first Py_Initialize()"); 603 } 604 } 605 606 _PyCoreConfig_SetGlobalConfig(core_config); 607 608 if (_PyCoreConfig_Copy(&interp->core_config, core_config) < 0) { 609 return _Py_INIT_ERR("failed to copy core config"); 610 } 611 return _Py_INIT_OK(); 612 } 613 614 615 /* Begin interpreter initialization 616 * 617 * On return, the first thread and interpreter state have been created, 618 * but the compiler, signal handling, multithreading and 619 * multiple interpreter support, and codec infrastructure are not yet 620 * available. 621 * 622 * The import system will support builtin and frozen modules only. 623 * The only supported io is writing to sys.stderr 624 * 625 * If any operation invoked by this function fails, a fatal error is 626 * issued and the function does not return. 627 * 628 * Any code invoked from this function should *not* assume it has access 629 * to the Python C API (unless the API is explicitly listed as being 630 * safe to call without calling Py_Initialize first) 631 */ 632 633 _PyInitError 634 _Py_InitializeCore_impl(PyInterpreterState **interp_p, 635 const _PyCoreConfig *core_config) 636 { 637 PyInterpreterState *interp; 638 _PyInitError err; 639 640 /* bpo-34008: For backward compatibility reasons, calling Py_Main() after 641 Py_Initialize() ignores the new configuration. */ 642 if (_PyRuntime.core_initialized) { 643 PyThreadState *tstate = PyThreadState_GET(); 644 if (!tstate) { 645 return _Py_INIT_ERR("no thread state found"); 646 } 647 648 interp = tstate->interp; 649 if (interp == NULL) { 650 return _Py_INIT_ERR("no main interpreter found"); 651 } 652 *interp_p = interp; 653 654 return _Py_Initialize_ReconfigureCore(interp, core_config); 655 } 656 657 658 _PyCoreConfig_SetGlobalConfig(core_config); 659 660 err = _PyRuntime_Initialize(); 661 if (_Py_INIT_FAILED(err)) { 662 return err; 663 } 664 665 if (core_config->allocator != NULL) { 666 if (_PyMem_SetupAllocators(core_config->allocator) < 0) { 667 return _Py_INIT_USER_ERR("Unknown PYTHONMALLOC allocator"); 668 } 669 } 670 671 if (_PyRuntime.initialized) { 672 return _Py_INIT_ERR("main interpreter already initialized"); 673 } 674 if (_PyRuntime.core_initialized) { 675 return _Py_INIT_ERR("runtime core already initialized"); 676 } 677 678 /* Py_Finalize leaves _Py_Finalizing set in order to help daemon 679 * threads behave a little more gracefully at interpreter shutdown. 680 * We clobber it here so the new interpreter can start with a clean 681 * slate. 682 * 683 * However, this may still lead to misbehaviour if there are daemon 684 * threads still hanging around from a previous Py_Initialize/Finalize 685 * pair :( 686 */ 687 _PyRuntime.finalizing = NULL; 688 689 #ifndef MS_WINDOWS 690 _emit_stderr_warning_for_legacy_locale(core_config); 691 #endif 692 693 err = _Py_HashRandomization_Init(core_config); 694 if (_Py_INIT_FAILED(err)) { 695 return err; 696 } 697 698 if (!core_config->use_hash_seed || core_config->hash_seed) { 699 /* Random or non-zero hash seed */ 700 Py_HashRandomizationFlag = 1; 701 } 702 703 err = _PyInterpreterState_Enable(&_PyRuntime); 704 if (_Py_INIT_FAILED(err)) { 705 return err; 706 } 707 708 interp = PyInterpreterState_New(); 709 if (interp == NULL) { 710 return _Py_INIT_ERR("can't make main interpreter"); 711 } 712 *interp_p = interp; 713 714 if (_PyCoreConfig_Copy(&interp->core_config, core_config) < 0) { 715 return _Py_INIT_ERR("failed to copy core config"); 716 } 717 718 PyThreadState *tstate = PyThreadState_New(interp); 719 if (tstate == NULL) 720 return _Py_INIT_ERR("can't make first thread"); 721 (void) PyThreadState_Swap(tstate); 722 723 /* We can't call _PyEval_FiniThreads() in Py_FinalizeEx because 724 destroying the GIL might fail when it is being referenced from 725 another running thread (see issue #9901). 726 Instead we destroy the previously created GIL here, which ensures 727 that we can call Py_Initialize / Py_FinalizeEx multiple times. */ 728 _PyEval_FiniThreads(); 729 730 /* Auto-thread-state API */ 731 _PyGILState_Init(interp, tstate); 732 733 /* Create the GIL */ 734 PyEval_InitThreads(); 735 736 _Py_ReadyTypes(); 737 738 if (!_PyFrame_Init()) 739 return _Py_INIT_ERR("can't init frames"); 740 741 if (!_PyLong_Init()) 742 return _Py_INIT_ERR("can't init longs"); 743 744 if (!PyByteArray_Init()) 745 return _Py_INIT_ERR("can't init bytearray"); 746 747 if (!_PyFloat_Init()) 748 return _Py_INIT_ERR("can't init float"); 749 750 PyObject *modules = PyDict_New(); 751 if (modules == NULL) 752 return _Py_INIT_ERR("can't make modules dictionary"); 753 interp->modules = modules; 754 755 PyObject *sysmod; 756 err = _PySys_BeginInit(&sysmod); 757 if (_Py_INIT_FAILED(err)) { 758 return err; 759 } 760 761 interp->sysdict = PyModule_GetDict(sysmod); 762 if (interp->sysdict == NULL) { 763 return _Py_INIT_ERR("can't initialize sys dict"); 764 } 765 766 Py_INCREF(interp->sysdict); 767 PyDict_SetItemString(interp->sysdict, "modules", modules); 768 _PyImport_FixupBuiltin(sysmod, "sys", modules); 769 770 /* Init Unicode implementation; relies on the codec registry */ 771 if (_PyUnicode_Init() < 0) 772 return _Py_INIT_ERR("can't initialize unicode"); 773 774 if (_PyStructSequence_Init() < 0) 775 return _Py_INIT_ERR("can't initialize structseq"); 776 777 PyObject *bimod = _PyBuiltin_Init(); 778 if (bimod == NULL) 779 return _Py_INIT_ERR("can't initialize builtins modules"); 780 _PyImport_FixupBuiltin(bimod, "builtins", modules); 781 interp->builtins = PyModule_GetDict(bimod); 782 if (interp->builtins == NULL) 783 return _Py_INIT_ERR("can't initialize builtins dict"); 784 Py_INCREF(interp->builtins); 785 786 /* initialize builtin exceptions */ 787 _PyExc_Init(bimod); 788 789 /* Set up a preliminary stderr printer until we have enough 790 infrastructure for the io module in place. */ 791 PyObject *pstderr = PyFile_NewStdPrinter(fileno(stderr)); 792 if (pstderr == NULL) 793 return _Py_INIT_ERR("can't set preliminary stderr"); 794 _PySys_SetObjectId(&PyId_stderr, pstderr); 795 PySys_SetObject("__stderr__", pstderr); 796 Py_DECREF(pstderr); 797 798 err = _PyImport_Init(interp); 799 if (_Py_INIT_FAILED(err)) { 800 return err; 801 } 802 803 err = _PyImportHooks_Init(); 804 if (_Py_INIT_FAILED(err)) { 805 return err; 806 } 807 808 /* Initialize _warnings. */ 809 if (_PyWarnings_Init() == NULL) { 810 return _Py_INIT_ERR("can't initialize warnings"); 811 } 812 813 if (!_PyContext_Init()) 814 return _Py_INIT_ERR("can't init context"); 815 816 /* This call sets up builtin and frozen import support */ 817 if (!interp->core_config._disable_importlib) { 818 err = initimport(interp, sysmod); 819 if (_Py_INIT_FAILED(err)) { 820 return err; 821 } 822 } 823 824 /* Only when we get here is the runtime core fully initialized */ 825 _PyRuntime.core_initialized = 1; 826 return _Py_INIT_OK(); 827 } 828 829 830 _PyInitError 831 _Py_InitializeCore(PyInterpreterState **interp_p, 832 const _PyCoreConfig *src_config) 833 { 834 assert(src_config != NULL); 835 836 PyMemAllocatorEx old_alloc; 837 _PyInitError err; 838 839 /* Copy the configuration, since _PyCoreConfig_Read() modifies it 840 (and the input configuration is read only). */ 841 _PyCoreConfig config = _PyCoreConfig_INIT; 842 843 #ifndef MS_WINDOWS 844 /* Set up the LC_CTYPE locale, so we can obtain the locale's charset 845 without having to switch locales. */ 846 _Py_SetLocaleFromEnv(LC_CTYPE); 847 #endif 848 849 _PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc); 850 if (_PyCoreConfig_Copy(&config, src_config) >= 0) { 851 err = _PyCoreConfig_Read(&config); 852 } 853 else { 854 err = _Py_INIT_ERR("failed to copy core config"); 855 } 856 PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc); 857 858 if (_Py_INIT_FAILED(err)) { 859 goto done; 860 } 861 862 err = _Py_InitializeCore_impl(interp_p, &config); 863 864 done: 865 _PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc); 866 _PyCoreConfig_Clear(&config); 867 PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc); 868 869 return err; 870 } 871 872 /* Py_Initialize() has already been called: update the main interpreter 873 configuration. Example of bpo-34008: Py_Main() called after 874 Py_Initialize(). */ 875 static _PyInitError 876 _Py_ReconfigureMainInterpreter(PyInterpreterState *interp, 877 const _PyMainInterpreterConfig *config) 878 { 879 if (config->argv != NULL) { 880 int res = PyDict_SetItemString(interp->sysdict, "argv", config->argv); 881 if (res < 0) { 882 return _Py_INIT_ERR("fail to set sys.argv"); 883 } 884 } 885 return _Py_INIT_OK(); 886 } 887 888 /* Update interpreter state based on supplied configuration settings 889 * 890 * After calling this function, most of the restrictions on the interpreter 891 * are lifted. The only remaining incomplete settings are those related 892 * to the main module (sys.argv[0], __main__ metadata) 893 * 894 * Calling this when the interpreter is not initializing, is already 895 * initialized or without a valid current thread state is a fatal error. 896 * Other errors should be reported as normal Python exceptions with a 897 * non-zero return code. 898 */ 899 _PyInitError 900 _Py_InitializeMainInterpreter(PyInterpreterState *interp, 901 const _PyMainInterpreterConfig *config) 902 { 903 _PyInitError err; 904 905 if (!_PyRuntime.core_initialized) { 906 return _Py_INIT_ERR("runtime core not initialized"); 907 } 908 909 /* Now finish configuring the main interpreter */ 910 if (_PyMainInterpreterConfig_Copy(&interp->config, config) < 0) { 911 return _Py_INIT_ERR("failed to copy main interpreter config"); 912 } 913 914 if (_PyRuntime.initialized) { 915 return _Py_ReconfigureMainInterpreter(interp, config); 916 } 917 918 if (interp->core_config._disable_importlib) { 919 /* Special mode for freeze_importlib: run with no import system 920 * 921 * This means anything which needs support from extension modules 922 * or pure Python code in the standard library won't work. 923 */ 924 _PyRuntime.initialized = 1; 925 return _Py_INIT_OK(); 926 } 927 928 if (_PyTime_Init() < 0) { 929 return _Py_INIT_ERR("can't initialize time"); 930 } 931 932 if (_PySys_EndInit(interp->sysdict, &interp->config) < 0) { 933 return _Py_INIT_ERR("can't finish initializing sys"); 934 } 935 936 err = initexternalimport(interp); 937 if (_Py_INIT_FAILED(err)) { 938 return err; 939 } 940 941 /* initialize the faulthandler module */ 942 err = _PyFaulthandler_Init(interp->core_config.faulthandler); 943 if (_Py_INIT_FAILED(err)) { 944 return err; 945 } 946 947 err = initfsencoding(interp); 948 if (_Py_INIT_FAILED(err)) { 949 return err; 950 } 951 952 if (interp->config.install_signal_handlers) { 953 err = initsigs(); /* Signal handling stuff, including initintr() */ 954 if (_Py_INIT_FAILED(err)) { 955 return err; 956 } 957 } 958 959 if (_PyTraceMalloc_Init(interp->core_config.tracemalloc) < 0) 960 return _Py_INIT_ERR("can't initialize tracemalloc"); 961 962 err = add_main_module(interp); 963 if (_Py_INIT_FAILED(err)) { 964 return err; 965 } 966 967 err = init_sys_streams(interp); 968 if (_Py_INIT_FAILED(err)) { 969 return err; 970 } 971 972 /* Initialize warnings. */ 973 if (interp->config.warnoptions != NULL && 974 PyList_Size(interp->config.warnoptions) > 0) 975 { 976 PyObject *warnings_module = PyImport_ImportModule("warnings"); 977 if (warnings_module == NULL) { 978 fprintf(stderr, "'import warnings' failed; traceback:\n"); 979 PyErr_Print(); 980 } 981 Py_XDECREF(warnings_module); 982 } 983 984 _PyRuntime.initialized = 1; 985 986 if (!Py_NoSiteFlag) { 987 err = initsite(); /* Module site */ 988 if (_Py_INIT_FAILED(err)) { 989 return err; 990 } 991 } 992 return _Py_INIT_OK(); 993 } 994 995 #undef _INIT_DEBUG_PRINT 996 997 998 _PyInitError 999 _Py_InitializeFromConfig(const _PyCoreConfig *config) 1000 { 1001 _Py_Initialize_ReadEnvVarsNoAlloc(); 1002 1003 PyInterpreterState *interp; 1004 _PyInitError err; 1005 err = _Py_InitializeCore(&interp, config); 1006 if (_Py_INIT_FAILED(err)) { 1007 return err; 1008 } 1009 config = &interp->core_config; 1010 1011 _PyMainInterpreterConfig main_config = _PyMainInterpreterConfig_INIT; 1012 err = _PyMainInterpreterConfig_Read(&main_config, config); 1013 if (!_Py_INIT_FAILED(err)) { 1014 err = _Py_InitializeMainInterpreter(interp, &main_config); 1015 } 1016 _PyMainInterpreterConfig_Clear(&main_config); 1017 if (_Py_INIT_FAILED(err)) { 1018 return err; 1019 } 1020 1021 return _Py_INIT_OK(); 1022 } 1023 1024 1025 void 1026 Py_InitializeEx(int install_sigs) 1027 { 1028 if (_PyRuntime.initialized) { 1029 /* bpo-33932: Calling Py_Initialize() twice does nothing. */ 1030 return; 1031 } 1032 1033 _PyInitError err; 1034 _PyCoreConfig config = _PyCoreConfig_INIT; 1035 config.install_signal_handlers = install_sigs; 1036 1037 err = _Py_InitializeFromConfig(&config); 1038 _PyCoreConfig_Clear(&config); 1039 1040 if (_Py_INIT_FAILED(err)) { 1041 _Py_FatalInitError(err); 1042 } 1043 } 1044 1045 void 1046 Py_Initialize(void) 1047 { 1048 Py_InitializeEx(1); 1049 } 1050 1051 1052 #ifdef COUNT_ALLOCS 1053 extern void dump_counts(FILE*); 1054 #endif 1055 1056 /* Flush stdout and stderr */ 1057 1058 static int 1059 file_is_closed(PyObject *fobj) 1060 { 1061 int r; 1062 PyObject *tmp = PyObject_GetAttrString(fobj, "closed"); 1063 if (tmp == NULL) { 1064 PyErr_Clear(); 1065 return 0; 1066 } 1067 r = PyObject_IsTrue(tmp); 1068 Py_DECREF(tmp); 1069 if (r < 0) 1070 PyErr_Clear(); 1071 return r > 0; 1072 } 1073 1074 static int 1075 flush_std_files(void) 1076 { 1077 PyObject *fout = _PySys_GetObjectId(&PyId_stdout); 1078 PyObject *ferr = _PySys_GetObjectId(&PyId_stderr); 1079 PyObject *tmp; 1080 int status = 0; 1081 1082 if (fout != NULL && fout != Py_None && !file_is_closed(fout)) { 1083 tmp = _PyObject_CallMethodId(fout, &PyId_flush, NULL); 1084 if (tmp == NULL) { 1085 PyErr_WriteUnraisable(fout); 1086 status = -1; 1087 } 1088 else 1089 Py_DECREF(tmp); 1090 } 1091 1092 if (ferr != NULL && ferr != Py_None && !file_is_closed(ferr)) { 1093 tmp = _PyObject_CallMethodId(ferr, &PyId_flush, NULL); 1094 if (tmp == NULL) { 1095 PyErr_Clear(); 1096 status = -1; 1097 } 1098 else 1099 Py_DECREF(tmp); 1100 } 1101 1102 return status; 1103 } 1104 1105 /* Undo the effect of Py_Initialize(). 1106 1107 Beware: if multiple interpreter and/or thread states exist, these 1108 are not wiped out; only the current thread and interpreter state 1109 are deleted. But since everything else is deleted, those other 1110 interpreter and thread states should no longer be used. 1111 1112 (XXX We should do better, e.g. wipe out all interpreters and 1113 threads.) 1114 1115 Locking: as above. 1116 1117 */ 1118 1119 int 1120 Py_FinalizeEx(void) 1121 { 1122 PyInterpreterState *interp; 1123 PyThreadState *tstate; 1124 int status = 0; 1125 1126 if (!_PyRuntime.initialized) 1127 return status; 1128 1129 wait_for_thread_shutdown(); 1130 1131 /* Get current thread state and interpreter pointer */ 1132 tstate = PyThreadState_GET(); 1133 interp = tstate->interp; 1134 1135 /* The interpreter is still entirely intact at this point, and the 1136 * exit funcs may be relying on that. In particular, if some thread 1137 * or exit func is still waiting to do an import, the import machinery 1138 * expects Py_IsInitialized() to return true. So don't say the 1139 * interpreter is uninitialized until after the exit funcs have run. 1140 * Note that Threading.py uses an exit func to do a join on all the 1141 * threads created thru it, so this also protects pending imports in 1142 * the threads created via Threading. 1143 */ 1144 1145 call_py_exitfuncs(interp); 1146 1147 /* Copy the core config, PyInterpreterState_Delete() free 1148 the core config memory */ 1149 #ifdef Py_REF_DEBUG 1150 int show_ref_count = interp->core_config.show_ref_count; 1151 #endif 1152 #ifdef Py_TRACE_REFS 1153 int dump_refs = interp->core_config.dump_refs; 1154 #endif 1155 #ifdef WITH_PYMALLOC 1156 int malloc_stats = interp->core_config.malloc_stats; 1157 #endif 1158 1159 /* Remaining threads (e.g. daemon threads) will automatically exit 1160 after taking the GIL (in PyEval_RestoreThread()). */ 1161 _PyRuntime.finalizing = tstate; 1162 _PyRuntime.initialized = 0; 1163 _PyRuntime.core_initialized = 0; 1164 1165 /* Flush sys.stdout and sys.stderr */ 1166 if (flush_std_files() < 0) { 1167 status = -1; 1168 } 1169 1170 /* Disable signal handling */ 1171 PyOS_FiniInterrupts(); 1172 1173 /* Collect garbage. This may call finalizers; it's nice to call these 1174 * before all modules are destroyed. 1175 * XXX If a __del__ or weakref callback is triggered here, and tries to 1176 * XXX import a module, bad things can happen, because Python no 1177 * XXX longer believes it's initialized. 1178 * XXX Fatal Python error: Interpreter not initialized (version mismatch?) 1179 * XXX is easy to provoke that way. I've also seen, e.g., 1180 * XXX Exception exceptions.ImportError: 'No module named sha' 1181 * XXX in <function callback at 0x008F5718> ignored 1182 * XXX but I'm unclear on exactly how that one happens. In any case, 1183 * XXX I haven't seen a real-life report of either of these. 1184 */ 1185 _PyGC_CollectIfEnabled(); 1186 #ifdef COUNT_ALLOCS 1187 /* With COUNT_ALLOCS, it helps to run GC multiple times: 1188 each collection might release some types from the type 1189 list, so they become garbage. */ 1190 while (_PyGC_CollectIfEnabled() > 0) 1191 /* nothing */; 1192 #endif 1193 1194 /* Destroy all modules */ 1195 PyImport_Cleanup(); 1196 1197 /* Flush sys.stdout and sys.stderr (again, in case more was printed) */ 1198 if (flush_std_files() < 0) { 1199 status = -1; 1200 } 1201 1202 /* Collect final garbage. This disposes of cycles created by 1203 * class definitions, for example. 1204 * XXX This is disabled because it caused too many problems. If 1205 * XXX a __del__ or weakref callback triggers here, Python code has 1206 * XXX a hard time running, because even the sys module has been 1207 * XXX cleared out (sys.stdout is gone, sys.excepthook is gone, etc). 1208 * XXX One symptom is a sequence of information-free messages 1209 * XXX coming from threads (if a __del__ or callback is invoked, 1210 * XXX other threads can execute too, and any exception they encounter 1211 * XXX triggers a comedy of errors as subsystem after subsystem 1212 * XXX fails to find what it *expects* to find in sys to help report 1213 * XXX the exception and consequent unexpected failures). I've also 1214 * XXX seen segfaults then, after adding print statements to the 1215 * XXX Python code getting called. 1216 */ 1217 #if 0 1218 _PyGC_CollectIfEnabled(); 1219 #endif 1220 1221 /* Disable tracemalloc after all Python objects have been destroyed, 1222 so it is possible to use tracemalloc in objects destructor. */ 1223 _PyTraceMalloc_Fini(); 1224 1225 /* Destroy the database used by _PyImport_{Fixup,Find}Extension */ 1226 _PyImport_Fini(); 1227 1228 /* Cleanup typeobject.c's internal caches. */ 1229 _PyType_Fini(); 1230 1231 /* unload faulthandler module */ 1232 _PyFaulthandler_Fini(); 1233 1234 /* Debugging stuff */ 1235 #ifdef COUNT_ALLOCS 1236 dump_counts(stderr); 1237 #endif 1238 /* dump hash stats */ 1239 _PyHash_Fini(); 1240 1241 #ifdef Py_REF_DEBUG 1242 if (show_ref_count) { 1243 _PyDebug_PrintTotalRefs(); 1244 } 1245 #endif 1246 1247 #ifdef Py_TRACE_REFS 1248 /* Display all objects still alive -- this can invoke arbitrary 1249 * __repr__ overrides, so requires a mostly-intact interpreter. 1250 * Alas, a lot of stuff may still be alive now that will be cleaned 1251 * up later. 1252 */ 1253 if (dump_refs) { 1254 _Py_PrintReferences(stderr); 1255 } 1256 #endif /* Py_TRACE_REFS */ 1257 1258 /* Clear interpreter state and all thread states. */ 1259 PyInterpreterState_Clear(interp); 1260 1261 /* Now we decref the exception classes. After this point nothing 1262 can raise an exception. That's okay, because each Fini() method 1263 below has been checked to make sure no exceptions are ever 1264 raised. 1265 */ 1266 1267 _PyExc_Fini(); 1268 1269 /* Sundry finalizers */ 1270 PyMethod_Fini(); 1271 PyFrame_Fini(); 1272 PyCFunction_Fini(); 1273 PyTuple_Fini(); 1274 PyList_Fini(); 1275 PySet_Fini(); 1276 PyBytes_Fini(); 1277 PyByteArray_Fini(); 1278 PyLong_Fini(); 1279 PyFloat_Fini(); 1280 PyDict_Fini(); 1281 PySlice_Fini(); 1282 _PyGC_Fini(); 1283 _Py_HashRandomization_Fini(); 1284 _PyArg_Fini(); 1285 PyAsyncGen_Fini(); 1286 _PyContext_Fini(); 1287 1288 /* Cleanup Unicode implementation */ 1289 _PyUnicode_Fini(); 1290 1291 /* reset file system default encoding */ 1292 if (!Py_HasFileSystemDefaultEncoding && Py_FileSystemDefaultEncoding) { 1293 PyMem_RawFree((char*)Py_FileSystemDefaultEncoding); 1294 Py_FileSystemDefaultEncoding = NULL; 1295 } 1296 1297 /* XXX Still allocated: 1298 - various static ad-hoc pointers to interned strings 1299 - int and float free list blocks 1300 - whatever various modules and libraries allocate 1301 */ 1302 1303 PyGrammar_RemoveAccelerators(&_PyParser_Grammar); 1304 1305 /* Cleanup auto-thread-state */ 1306 _PyGILState_Fini(); 1307 1308 /* Delete current thread. After this, many C API calls become crashy. */ 1309 PyThreadState_Swap(NULL); 1310 1311 PyInterpreterState_Delete(interp); 1312 1313 #ifdef Py_TRACE_REFS 1314 /* Display addresses (& refcnts) of all objects still alive. 1315 * An address can be used to find the repr of the object, printed 1316 * above by _Py_PrintReferences. 1317 */ 1318 if (dump_refs) { 1319 _Py_PrintReferenceAddresses(stderr); 1320 } 1321 #endif /* Py_TRACE_REFS */ 1322 #ifdef WITH_PYMALLOC 1323 if (malloc_stats) { 1324 _PyObject_DebugMallocStats(stderr); 1325 } 1326 #endif 1327 1328 call_ll_exitfuncs(); 1329 1330 _PyRuntime_Finalize(); 1331 return status; 1332 } 1333 1334 void 1335 Py_Finalize(void) 1336 { 1337 Py_FinalizeEx(); 1338 } 1339 1340 /* Create and initialize a new interpreter and thread, and return the 1341 new thread. This requires that Py_Initialize() has been called 1342 first. 1343 1344 Unsuccessful initialization yields a NULL pointer. Note that *no* 1345 exception information is available even in this case -- the 1346 exception information is held in the thread, and there is no 1347 thread. 1348 1349 Locking: as above. 1350 1351 */ 1352 1353 static _PyInitError 1354 new_interpreter(PyThreadState **tstate_p) 1355 { 1356 PyInterpreterState *interp; 1357 PyThreadState *tstate, *save_tstate; 1358 PyObject *bimod, *sysmod; 1359 _PyInitError err; 1360 1361 if (!_PyRuntime.initialized) { 1362 return _Py_INIT_ERR("Py_Initialize must be called first"); 1363 } 1364 1365 /* Issue #10915, #15751: The GIL API doesn't work with multiple 1366 interpreters: disable PyGILState_Check(). */ 1367 _PyGILState_check_enabled = 0; 1368 1369 interp = PyInterpreterState_New(); 1370 if (interp == NULL) { 1371 *tstate_p = NULL; 1372 return _Py_INIT_OK(); 1373 } 1374 1375 tstate = PyThreadState_New(interp); 1376 if (tstate == NULL) { 1377 PyInterpreterState_Delete(interp); 1378 *tstate_p = NULL; 1379 return _Py_INIT_OK(); 1380 } 1381 1382 save_tstate = PyThreadState_Swap(tstate); 1383 1384 /* Copy the current interpreter config into the new interpreter */ 1385 _PyCoreConfig *core_config; 1386 _PyMainInterpreterConfig *config; 1387 if (save_tstate != NULL) { 1388 core_config = &save_tstate->interp->core_config; 1389 config = &save_tstate->interp->config; 1390 } else { 1391 /* No current thread state, copy from the main interpreter */ 1392 PyInterpreterState *main_interp = PyInterpreterState_Main(); 1393 core_config = &main_interp->core_config; 1394 config = &main_interp->config; 1395 } 1396 1397 if (_PyCoreConfig_Copy(&interp->core_config, core_config) < 0) { 1398 return _Py_INIT_ERR("failed to copy core config"); 1399 } 1400 if (_PyMainInterpreterConfig_Copy(&interp->config, config) < 0) { 1401 return _Py_INIT_ERR("failed to copy main interpreter config"); 1402 } 1403 1404 /* XXX The following is lax in error checking */ 1405 PyObject *modules = PyDict_New(); 1406 if (modules == NULL) { 1407 return _Py_INIT_ERR("can't make modules dictionary"); 1408 } 1409 interp->modules = modules; 1410 1411 sysmod = _PyImport_FindBuiltin("sys", modules); 1412 if (sysmod != NULL) { 1413 interp->sysdict = PyModule_GetDict(sysmod); 1414 if (interp->sysdict == NULL) 1415 goto handle_error; 1416 Py_INCREF(interp->sysdict); 1417 PyDict_SetItemString(interp->sysdict, "modules", modules); 1418 _PySys_EndInit(interp->sysdict, &interp->config); 1419 } 1420 else if (PyErr_Occurred()) { 1421 goto handle_error; 1422 } 1423 1424 bimod = _PyImport_FindBuiltin("builtins", modules); 1425 if (bimod != NULL) { 1426 interp->builtins = PyModule_GetDict(bimod); 1427 if (interp->builtins == NULL) 1428 goto handle_error; 1429 Py_INCREF(interp->builtins); 1430 } 1431 else if (PyErr_Occurred()) { 1432 goto handle_error; 1433 } 1434 1435 /* initialize builtin exceptions */ 1436 _PyExc_Init(bimod); 1437 1438 if (bimod != NULL && sysmod != NULL) { 1439 PyObject *pstderr; 1440 1441 /* Set up a preliminary stderr printer until we have enough 1442 infrastructure for the io module in place. */ 1443 pstderr = PyFile_NewStdPrinter(fileno(stderr)); 1444 if (pstderr == NULL) { 1445 return _Py_INIT_ERR("can't set preliminary stderr"); 1446 } 1447 _PySys_SetObjectId(&PyId_stderr, pstderr); 1448 PySys_SetObject("__stderr__", pstderr); 1449 Py_DECREF(pstderr); 1450 1451 err = _PyImportHooks_Init(); 1452 if (_Py_INIT_FAILED(err)) { 1453 return err; 1454 } 1455 1456 err = initimport(interp, sysmod); 1457 if (_Py_INIT_FAILED(err)) { 1458 return err; 1459 } 1460 1461 err = initexternalimport(interp); 1462 if (_Py_INIT_FAILED(err)) { 1463 return err; 1464 } 1465 1466 err = initfsencoding(interp); 1467 if (_Py_INIT_FAILED(err)) { 1468 return err; 1469 } 1470 1471 err = init_sys_streams(interp); 1472 if (_Py_INIT_FAILED(err)) { 1473 return err; 1474 } 1475 1476 err = add_main_module(interp); 1477 if (_Py_INIT_FAILED(err)) { 1478 return err; 1479 } 1480 1481 if (!Py_NoSiteFlag) { 1482 err = initsite(); 1483 if (_Py_INIT_FAILED(err)) { 1484 return err; 1485 } 1486 } 1487 } 1488 1489 if (PyErr_Occurred()) { 1490 goto handle_error; 1491 } 1492 1493 *tstate_p = tstate; 1494 return _Py_INIT_OK(); 1495 1496 handle_error: 1497 /* Oops, it didn't work. Undo it all. */ 1498 1499 PyErr_PrintEx(0); 1500 PyThreadState_Clear(tstate); 1501 PyThreadState_Swap(save_tstate); 1502 PyThreadState_Delete(tstate); 1503 PyInterpreterState_Delete(interp); 1504 1505 *tstate_p = NULL; 1506 return _Py_INIT_OK(); 1507 } 1508 1509 PyThreadState * 1510 Py_NewInterpreter(void) 1511 { 1512 PyThreadState *tstate; 1513 _PyInitError err = new_interpreter(&tstate); 1514 if (_Py_INIT_FAILED(err)) { 1515 _Py_FatalInitError(err); 1516 } 1517 return tstate; 1518 1519 } 1520 1521 /* Delete an interpreter and its last thread. This requires that the 1522 given thread state is current, that the thread has no remaining 1523 frames, and that it is its interpreter's only remaining thread. 1524 It is a fatal error to violate these constraints. 1525 1526 (Py_FinalizeEx() doesn't have these constraints -- it zaps 1527 everything, regardless.) 1528 1529 Locking: as above. 1530 1531 */ 1532 1533 void 1534 Py_EndInterpreter(PyThreadState *tstate) 1535 { 1536 PyInterpreterState *interp = tstate->interp; 1537 1538 if (tstate != PyThreadState_GET()) 1539 Py_FatalError("Py_EndInterpreter: thread is not current"); 1540 if (tstate->frame != NULL) 1541 Py_FatalError("Py_EndInterpreter: thread still has a frame"); 1542 1543 wait_for_thread_shutdown(); 1544 1545 call_py_exitfuncs(interp); 1546 1547 if (tstate != interp->tstate_head || tstate->next != NULL) 1548 Py_FatalError("Py_EndInterpreter: not the last thread"); 1549 1550 PyImport_Cleanup(); 1551 PyInterpreterState_Clear(interp); 1552 PyThreadState_Swap(NULL); 1553 PyInterpreterState_Delete(interp); 1554 } 1555 1556 /* Add the __main__ module */ 1557 1558 static _PyInitError 1559 add_main_module(PyInterpreterState *interp) 1560 { 1561 PyObject *m, *d, *loader, *ann_dict; 1562 m = PyImport_AddModule("__main__"); 1563 if (m == NULL) 1564 return _Py_INIT_ERR("can't create __main__ module"); 1565 1566 d = PyModule_GetDict(m); 1567 ann_dict = PyDict_New(); 1568 if ((ann_dict == NULL) || 1569 (PyDict_SetItemString(d, "__annotations__", ann_dict) < 0)) { 1570 return _Py_INIT_ERR("Failed to initialize __main__.__annotations__"); 1571 } 1572 Py_DECREF(ann_dict); 1573 1574 if (PyDict_GetItemString(d, "__builtins__") == NULL) { 1575 PyObject *bimod = PyImport_ImportModule("builtins"); 1576 if (bimod == NULL) { 1577 return _Py_INIT_ERR("Failed to retrieve builtins module"); 1578 } 1579 if (PyDict_SetItemString(d, "__builtins__", bimod) < 0) { 1580 return _Py_INIT_ERR("Failed to initialize __main__.__builtins__"); 1581 } 1582 Py_DECREF(bimod); 1583 } 1584 1585 /* Main is a little special - imp.is_builtin("__main__") will return 1586 * False, but BuiltinImporter is still the most appropriate initial 1587 * setting for its __loader__ attribute. A more suitable value will 1588 * be set if __main__ gets further initialized later in the startup 1589 * process. 1590 */ 1591 loader = PyDict_GetItemString(d, "__loader__"); 1592 if (loader == NULL || loader == Py_None) { 1593 PyObject *loader = PyObject_GetAttrString(interp->importlib, 1594 "BuiltinImporter"); 1595 if (loader == NULL) { 1596 return _Py_INIT_ERR("Failed to retrieve BuiltinImporter"); 1597 } 1598 if (PyDict_SetItemString(d, "__loader__", loader) < 0) { 1599 return _Py_INIT_ERR("Failed to initialize __main__.__loader__"); 1600 } 1601 Py_DECREF(loader); 1602 } 1603 return _Py_INIT_OK(); 1604 } 1605 1606 static _PyInitError 1607 initfsencoding(PyInterpreterState *interp) 1608 { 1609 PyObject *codec; 1610 1611 #ifdef MS_WINDOWS 1612 if (Py_LegacyWindowsFSEncodingFlag) { 1613 Py_FileSystemDefaultEncoding = "mbcs"; 1614 Py_FileSystemDefaultEncodeErrors = "replace"; 1615 } 1616 else { 1617 Py_FileSystemDefaultEncoding = "utf-8"; 1618 Py_FileSystemDefaultEncodeErrors = "surrogatepass"; 1619 } 1620 #else 1621 if (Py_FileSystemDefaultEncoding == NULL && 1622 interp->core_config.utf8_mode) 1623 { 1624 Py_FileSystemDefaultEncoding = "utf-8"; 1625 Py_HasFileSystemDefaultEncoding = 1; 1626 } 1627 else if (_Py_GetForceASCII()) { 1628 Py_FileSystemDefaultEncoding = "ascii"; 1629 Py_HasFileSystemDefaultEncoding = 1; 1630 } 1631 else if (Py_FileSystemDefaultEncoding == NULL) { 1632 Py_FileSystemDefaultEncoding = get_locale_encoding(); 1633 if (Py_FileSystemDefaultEncoding == NULL) { 1634 return _Py_INIT_ERR("Unable to get the locale encoding"); 1635 } 1636 1637 Py_HasFileSystemDefaultEncoding = 0; 1638 interp->fscodec_initialized = 1; 1639 return _Py_INIT_OK(); 1640 } 1641 #endif 1642 1643 /* the encoding is mbcs, utf-8 or ascii */ 1644 codec = _PyCodec_Lookup(Py_FileSystemDefaultEncoding); 1645 if (!codec) { 1646 /* Such error can only occurs in critical situations: no more 1647 * memory, import a module of the standard library failed, 1648 * etc. */ 1649 return _Py_INIT_ERR("unable to load the file system codec"); 1650 } 1651 Py_DECREF(codec); 1652 interp->fscodec_initialized = 1; 1653 return _Py_INIT_OK(); 1654 } 1655 1656 /* Import the site module (not into __main__ though) */ 1657 1658 static _PyInitError 1659 initsite(void) 1660 { 1661 PyObject *m; 1662 m = PyImport_ImportModule("site"); 1663 if (m == NULL) { 1664 return _Py_INIT_USER_ERR("Failed to import the site module"); 1665 } 1666 Py_DECREF(m); 1667 return _Py_INIT_OK(); 1668 } 1669 1670 /* Check if a file descriptor is valid or not. 1671 Return 0 if the file descriptor is invalid, return non-zero otherwise. */ 1672 static int 1673 is_valid_fd(int fd) 1674 { 1675 #ifdef __APPLE__ 1676 /* bpo-30225: On macOS Tiger, when stdout is redirected to a pipe 1677 and the other side of the pipe is closed, dup(1) succeed, whereas 1678 fstat(1, &st) fails with EBADF. Prefer fstat() over dup() to detect 1679 such error. */ 1680 struct stat st; 1681 return (fstat(fd, &st) == 0); 1682 #else 1683 int fd2; 1684 if (fd < 0) 1685 return 0; 1686 _Py_BEGIN_SUPPRESS_IPH 1687 /* Prefer dup() over fstat(). fstat() can require input/output whereas 1688 dup() doesn't, there is a low risk of EMFILE/ENFILE at Python 1689 startup. */ 1690 fd2 = dup(fd); 1691 if (fd2 >= 0) 1692 close(fd2); 1693 _Py_END_SUPPRESS_IPH 1694 return fd2 >= 0; 1695 #endif 1696 } 1697 1698 /* returns Py_None if the fd is not valid */ 1699 static PyObject* 1700 create_stdio(PyObject* io, 1701 int fd, int write_mode, const char* name, 1702 const char* encoding, const char* errors) 1703 { 1704 PyObject *buf = NULL, *stream = NULL, *text = NULL, *raw = NULL, *res; 1705 const char* mode; 1706 const char* newline; 1707 PyObject *line_buffering, *write_through; 1708 int buffering, isatty; 1709 _Py_IDENTIFIER(open); 1710 _Py_IDENTIFIER(isatty); 1711 _Py_IDENTIFIER(TextIOWrapper); 1712 _Py_IDENTIFIER(mode); 1713 1714 if (!is_valid_fd(fd)) 1715 Py_RETURN_NONE; 1716 1717 /* stdin is always opened in buffered mode, first because it shouldn't 1718 make a difference in common use cases, second because TextIOWrapper 1719 depends on the presence of a read1() method which only exists on 1720 buffered streams. 1721 */ 1722 if (Py_UnbufferedStdioFlag && write_mode) 1723 buffering = 0; 1724 else 1725 buffering = -1; 1726 if (write_mode) 1727 mode = "wb"; 1728 else 1729 mode = "rb"; 1730 buf = _PyObject_CallMethodId(io, &PyId_open, "isiOOOi", 1731 fd, mode, buffering, 1732 Py_None, Py_None, /* encoding, errors */ 1733 Py_None, 0); /* newline, closefd */ 1734 if (buf == NULL) 1735 goto error; 1736 1737 if (buffering) { 1738 _Py_IDENTIFIER(raw); 1739 raw = _PyObject_GetAttrId(buf, &PyId_raw); 1740 if (raw == NULL) 1741 goto error; 1742 } 1743 else { 1744 raw = buf; 1745 Py_INCREF(raw); 1746 } 1747 1748 #ifdef MS_WINDOWS 1749 /* Windows console IO is always UTF-8 encoded */ 1750 if (PyWindowsConsoleIO_Check(raw)) 1751 encoding = "utf-8"; 1752 #endif 1753 1754 text = PyUnicode_FromString(name); 1755 if (text == NULL || _PyObject_SetAttrId(raw, &PyId_name, text) < 0) 1756 goto error; 1757 res = _PyObject_CallMethodId(raw, &PyId_isatty, NULL); 1758 if (res == NULL) 1759 goto error; 1760 isatty = PyObject_IsTrue(res); 1761 Py_DECREF(res); 1762 if (isatty == -1) 1763 goto error; 1764 if (Py_UnbufferedStdioFlag) 1765 write_through = Py_True; 1766 else 1767 write_through = Py_False; 1768 if (isatty && !Py_UnbufferedStdioFlag) 1769 line_buffering = Py_True; 1770 else 1771 line_buffering = Py_False; 1772 1773 Py_CLEAR(raw); 1774 Py_CLEAR(text); 1775 1776 #ifdef MS_WINDOWS 1777 /* sys.stdin: enable universal newline mode, translate "\r\n" and "\r" 1778 newlines to "\n". 1779 sys.stdout and sys.stderr: translate "\n" to "\r\n". */ 1780 newline = NULL; 1781 #else 1782 /* sys.stdin: split lines at "\n". 1783 sys.stdout and sys.stderr: don't translate newlines (use "\n"). */ 1784 newline = "\n"; 1785 #endif 1786 1787 stream = _PyObject_CallMethodId(io, &PyId_TextIOWrapper, "OsssOO", 1788 buf, encoding, errors, 1789 newline, line_buffering, write_through); 1790 Py_CLEAR(buf); 1791 if (stream == NULL) 1792 goto error; 1793 1794 if (write_mode) 1795 mode = "w"; 1796 else 1797 mode = "r"; 1798 text = PyUnicode_FromString(mode); 1799 if (!text || _PyObject_SetAttrId(stream, &PyId_mode, text) < 0) 1800 goto error; 1801 Py_CLEAR(text); 1802 return stream; 1803 1804 error: 1805 Py_XDECREF(buf); 1806 Py_XDECREF(stream); 1807 Py_XDECREF(text); 1808 Py_XDECREF(raw); 1809 1810 if (PyErr_ExceptionMatches(PyExc_OSError) && !is_valid_fd(fd)) { 1811 /* Issue #24891: the file descriptor was closed after the first 1812 is_valid_fd() check was called. Ignore the OSError and set the 1813 stream to None. */ 1814 PyErr_Clear(); 1815 Py_RETURN_NONE; 1816 } 1817 return NULL; 1818 } 1819 1820 /* Initialize sys.stdin, stdout, stderr and builtins.open */ 1821 static _PyInitError 1822 init_sys_streams(PyInterpreterState *interp) 1823 { 1824 PyObject *iomod = NULL, *wrapper; 1825 PyObject *bimod = NULL; 1826 PyObject *m; 1827 PyObject *std = NULL; 1828 int fd; 1829 PyObject * encoding_attr; 1830 char *pythonioencoding = NULL; 1831 const char *encoding, *errors; 1832 _PyInitError res = _Py_INIT_OK(); 1833 1834 /* Hack to avoid a nasty recursion issue when Python is invoked 1835 in verbose mode: pre-import the Latin-1 and UTF-8 codecs */ 1836 if ((m = PyImport_ImportModule("encodings.utf_8")) == NULL) { 1837 goto error; 1838 } 1839 Py_DECREF(m); 1840 1841 if (!(m = PyImport_ImportModule("encodings.latin_1"))) { 1842 goto error; 1843 } 1844 Py_DECREF(m); 1845 1846 if (!(bimod = PyImport_ImportModule("builtins"))) { 1847 goto error; 1848 } 1849 1850 if (!(iomod = PyImport_ImportModule("io"))) { 1851 goto error; 1852 } 1853 if (!(wrapper = PyObject_GetAttrString(iomod, "OpenWrapper"))) { 1854 goto error; 1855 } 1856 1857 /* Set builtins.open */ 1858 if (PyObject_SetAttrString(bimod, "open", wrapper) == -1) { 1859 Py_DECREF(wrapper); 1860 goto error; 1861 } 1862 Py_DECREF(wrapper); 1863 1864 encoding = _Py_StandardStreamEncoding; 1865 errors = _Py_StandardStreamErrors; 1866 if (!encoding || !errors) { 1867 char *opt = Py_GETENV("PYTHONIOENCODING"); 1868 if (opt && opt[0] != '\0') { 1869 char *err; 1870 pythonioencoding = _PyMem_Strdup(opt); 1871 if (pythonioencoding == NULL) { 1872 PyErr_NoMemory(); 1873 goto error; 1874 } 1875 err = strchr(pythonioencoding, ':'); 1876 if (err) { 1877 *err = '\0'; 1878 err++; 1879 if (!err[0]) { 1880 err = NULL; 1881 } 1882 } 1883 1884 /* Does PYTHONIOENCODING contain an encoding? */ 1885 if (pythonioencoding[0]) { 1886 if (!encoding) { 1887 encoding = pythonioencoding; 1888 } 1889 1890 /* If the encoding is set but not the error handler, 1891 use "strict" error handler by default. 1892 PYTHONIOENCODING=latin1 behaves as 1893 PYTHONIOENCODING=latin1:strict. */ 1894 if (!err) { 1895 err = "strict"; 1896 } 1897 } 1898 1899 if (!errors && err != NULL) { 1900 errors = err; 1901 } 1902 } 1903 1904 if (interp->core_config.utf8_mode) { 1905 if (!encoding) { 1906 encoding = "utf-8"; 1907 } 1908 if (!errors) { 1909 errors = "surrogateescape"; 1910 } 1911 } 1912 1913 1914 if (!errors) { 1915 /* Choose the default error handler based on the current locale */ 1916 errors = get_default_standard_stream_error_handler(); 1917 } 1918 } 1919 1920 /* Set sys.stdin */ 1921 fd = fileno(stdin); 1922 /* Under some conditions stdin, stdout and stderr may not be connected 1923 * and fileno() may point to an invalid file descriptor. For example 1924 * GUI apps don't have valid standard streams by default. 1925 */ 1926 std = create_stdio(iomod, fd, 0, "<stdin>", encoding, errors); 1927 if (std == NULL) 1928 goto error; 1929 PySys_SetObject("__stdin__", std); 1930 _PySys_SetObjectId(&PyId_stdin, std); 1931 Py_DECREF(std); 1932 1933 /* Set sys.stdout */ 1934 fd = fileno(stdout); 1935 std = create_stdio(iomod, fd, 1, "<stdout>", encoding, errors); 1936 if (std == NULL) 1937 goto error; 1938 PySys_SetObject("__stdout__", std); 1939 _PySys_SetObjectId(&PyId_stdout, std); 1940 Py_DECREF(std); 1941 1942 #if 1 /* Disable this if you have trouble debugging bootstrap stuff */ 1943 /* Set sys.stderr, replaces the preliminary stderr */ 1944 fd = fileno(stderr); 1945 std = create_stdio(iomod, fd, 1, "<stderr>", encoding, "backslashreplace"); 1946 if (std == NULL) 1947 goto error; 1948 1949 /* Same as hack above, pre-import stderr's codec to avoid recursion 1950 when import.c tries to write to stderr in verbose mode. */ 1951 encoding_attr = PyObject_GetAttrString(std, "encoding"); 1952 if (encoding_attr != NULL) { 1953 const char *std_encoding = PyUnicode_AsUTF8(encoding_attr); 1954 if (std_encoding != NULL) { 1955 PyObject *codec_info = _PyCodec_Lookup(std_encoding); 1956 Py_XDECREF(codec_info); 1957 } 1958 Py_DECREF(encoding_attr); 1959 } 1960 PyErr_Clear(); /* Not a fatal error if codec isn't available */ 1961 1962 if (PySys_SetObject("__stderr__", std) < 0) { 1963 Py_DECREF(std); 1964 goto error; 1965 } 1966 if (_PySys_SetObjectId(&PyId_stderr, std) < 0) { 1967 Py_DECREF(std); 1968 goto error; 1969 } 1970 Py_DECREF(std); 1971 #endif 1972 1973 goto done; 1974 1975 error: 1976 res = _Py_INIT_ERR("can't initialize sys standard streams"); 1977 1978 /* Use the same allocator than Py_SetStandardStreamEncoding() */ 1979 PyMemAllocatorEx old_alloc; 1980 done: 1981 _PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc); 1982 1983 /* We won't need them anymore. */ 1984 if (_Py_StandardStreamEncoding) { 1985 PyMem_RawFree(_Py_StandardStreamEncoding); 1986 _Py_StandardStreamEncoding = NULL; 1987 } 1988 if (_Py_StandardStreamErrors) { 1989 PyMem_RawFree(_Py_StandardStreamErrors); 1990 _Py_StandardStreamErrors = NULL; 1991 } 1992 1993 PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc); 1994 1995 PyMem_Free(pythonioencoding); 1996 Py_XDECREF(bimod); 1997 Py_XDECREF(iomod); 1998 return res; 1999 } 2000 2001 2002 static void 2003 _Py_FatalError_DumpTracebacks(int fd) 2004 { 2005 fputc('\n', stderr); 2006 fflush(stderr); 2007 2008 /* display the current Python stack */ 2009 _Py_DumpTracebackThreads(fd, NULL, NULL); 2010 } 2011 2012 /* Print the current exception (if an exception is set) with its traceback, 2013 or display the current Python stack. 2014 2015 Don't call PyErr_PrintEx() and the except hook, because Py_FatalError() is 2016 called on catastrophic cases. 2017 2018 Return 1 if the traceback was displayed, 0 otherwise. */ 2019 2020 static int 2021 _Py_FatalError_PrintExc(int fd) 2022 { 2023 PyObject *ferr, *res; 2024 PyObject *exception, *v, *tb; 2025 int has_tb; 2026 2027 PyErr_Fetch(&exception, &v, &tb); 2028 if (exception == NULL) { 2029 /* No current exception */ 2030 return 0; 2031 } 2032 2033 ferr = _PySys_GetObjectId(&PyId_stderr); 2034 if (ferr == NULL || ferr == Py_None) { 2035 /* sys.stderr is not set yet or set to None, 2036 no need to try to display the exception */ 2037 return 0; 2038 } 2039 2040 PyErr_NormalizeException(&exception, &v, &tb); 2041 if (tb == NULL) { 2042 tb = Py_None; 2043 Py_INCREF(tb); 2044 } 2045 PyException_SetTraceback(v, tb); 2046 if (exception == NULL) { 2047 /* PyErr_NormalizeException() failed */ 2048 return 0; 2049 } 2050 2051 has_tb = (tb != Py_None); 2052 PyErr_Display(exception, v, tb); 2053 Py_XDECREF(exception); 2054 Py_XDECREF(v); 2055 Py_XDECREF(tb); 2056 2057 /* sys.stderr may be buffered: call sys.stderr.flush() */ 2058 res = _PyObject_CallMethodId(ferr, &PyId_flush, NULL); 2059 if (res == NULL) 2060 PyErr_Clear(); 2061 else 2062 Py_DECREF(res); 2063 2064 return has_tb; 2065 } 2066 2067 /* Print fatal error message and abort */ 2068 2069 #ifdef MS_WINDOWS 2070 static void 2071 fatal_output_debug(const char *msg) 2072 { 2073 /* buffer of 256 bytes allocated on the stack */ 2074 WCHAR buffer[256 / sizeof(WCHAR)]; 2075 size_t buflen = Py_ARRAY_LENGTH(buffer) - 1; 2076 size_t msglen; 2077 2078 OutputDebugStringW(L"Fatal Python error: "); 2079 2080 msglen = strlen(msg); 2081 while (msglen) { 2082 size_t i; 2083 2084 if (buflen > msglen) { 2085 buflen = msglen; 2086 } 2087 2088 /* Convert the message to wchar_t. This uses a simple one-to-one 2089 conversion, assuming that the this error message actually uses 2090 ASCII only. If this ceases to be true, we will have to convert. */ 2091 for (i=0; i < buflen; ++i) { 2092 buffer[i] = msg[i]; 2093 } 2094 buffer[i] = L'\0'; 2095 OutputDebugStringW(buffer); 2096 2097 msg += buflen; 2098 msglen -= buflen; 2099 } 2100 OutputDebugStringW(L"\n"); 2101 } 2102 #endif 2103 2104 static void _Py_NO_RETURN 2105 fatal_error(const char *prefix, const char *msg, int status) 2106 { 2107 const int fd = fileno(stderr); 2108 static int reentrant = 0; 2109 2110 if (reentrant) { 2111 /* Py_FatalError() caused a second fatal error. 2112 Example: flush_std_files() raises a recursion error. */ 2113 goto exit; 2114 } 2115 reentrant = 1; 2116 2117 fprintf(stderr, "Fatal Python error: "); 2118 if (prefix) { 2119 fputs(prefix, stderr); 2120 fputs(": ", stderr); 2121 } 2122 if (msg) { 2123 fputs(msg, stderr); 2124 } 2125 else { 2126 fprintf(stderr, "<message not set>"); 2127 } 2128 fputs("\n", stderr); 2129 fflush(stderr); /* it helps in Windows debug build */ 2130 2131 /* Check if the current thread has a Python thread state 2132 and holds the GIL */ 2133 PyThreadState *tss_tstate = PyGILState_GetThisThreadState(); 2134 if (tss_tstate != NULL) { 2135 PyThreadState *tstate = PyThreadState_GET(); 2136 if (tss_tstate != tstate) { 2137 /* The Python thread does not hold the GIL */ 2138 tss_tstate = NULL; 2139 } 2140 } 2141 else { 2142 /* Py_FatalError() has been called from a C thread 2143 which has no Python thread state. */ 2144 } 2145 int has_tstate_and_gil = (tss_tstate != NULL); 2146 2147 if (has_tstate_and_gil) { 2148 /* If an exception is set, print the exception with its traceback */ 2149 if (!_Py_FatalError_PrintExc(fd)) { 2150 /* No exception is set, or an exception is set without traceback */ 2151 _Py_FatalError_DumpTracebacks(fd); 2152 } 2153 } 2154 else { 2155 _Py_FatalError_DumpTracebacks(fd); 2156 } 2157 2158 /* The main purpose of faulthandler is to display the traceback. 2159 This function already did its best to display a traceback. 2160 Disable faulthandler to prevent writing a second traceback 2161 on abort(). */ 2162 _PyFaulthandler_Fini(); 2163 2164 /* Check if the current Python thread hold the GIL */ 2165 if (has_tstate_and_gil) { 2166 /* Flush sys.stdout and sys.stderr */ 2167 flush_std_files(); 2168 } 2169 2170 #ifdef MS_WINDOWS 2171 fatal_output_debug(msg); 2172 #endif /* MS_WINDOWS */ 2173 2174 exit: 2175 if (status < 0) { 2176 #if defined(MS_WINDOWS) && defined(_DEBUG) 2177 DebugBreak(); 2178 #endif 2179 abort(); 2180 } 2181 else { 2182 exit(status); 2183 } 2184 } 2185 2186 void _Py_NO_RETURN 2187 Py_FatalError(const char *msg) 2188 { 2189 fatal_error(NULL, msg, -1); 2190 } 2191 2192 void _Py_NO_RETURN 2193 _Py_FatalInitError(_PyInitError err) 2194 { 2195 /* On "user" error: exit with status 1. 2196 For all other errors, call abort(). */ 2197 int status = err.user_err ? 1 : -1; 2198 fatal_error(err.prefix, err.msg, status); 2199 } 2200 2201 /* Clean up and exit */ 2202 2203 # include "pythread.h" 2204 2205 /* For the atexit module. */ 2206 void _Py_PyAtExit(void (*func)(PyObject *), PyObject *module) 2207 { 2208 PyThreadState *ts; 2209 PyInterpreterState *is; 2210 2211 ts = PyThreadState_GET(); 2212 is = ts->interp; 2213 2214 /* Guard against API misuse (see bpo-17852) */ 2215 assert(is->pyexitfunc == NULL || is->pyexitfunc == func); 2216 2217 is->pyexitfunc = func; 2218 is->pyexitmodule = module; 2219 } 2220 2221 static void 2222 call_py_exitfuncs(PyInterpreterState *istate) 2223 { 2224 if (istate->pyexitfunc == NULL) 2225 return; 2226 2227 (*istate->pyexitfunc)(istate->pyexitmodule); 2228 PyErr_Clear(); 2229 } 2230 2231 /* Wait until threading._shutdown completes, provided 2232 the threading module was imported in the first place. 2233 The shutdown routine will wait until all non-daemon 2234 "threading" threads have completed. */ 2235 static void 2236 wait_for_thread_shutdown(void) 2237 { 2238 _Py_IDENTIFIER(_shutdown); 2239 PyObject *result; 2240 PyObject *threading = _PyImport_GetModuleId(&PyId_threading); 2241 if (threading == NULL) { 2242 /* threading not imported */ 2243 PyErr_Clear(); 2244 return; 2245 } 2246 result = _PyObject_CallMethodId(threading, &PyId__shutdown, NULL); 2247 if (result == NULL) { 2248 PyErr_WriteUnraisable(threading); 2249 } 2250 else { 2251 Py_DECREF(result); 2252 } 2253 Py_DECREF(threading); 2254 } 2255 2256 #define NEXITFUNCS 32 2257 int Py_AtExit(void (*func)(void)) 2258 { 2259 if (_PyRuntime.nexitfuncs >= NEXITFUNCS) 2260 return -1; 2261 _PyRuntime.exitfuncs[_PyRuntime.nexitfuncs++] = func; 2262 return 0; 2263 } 2264 2265 static void 2266 call_ll_exitfuncs(void) 2267 { 2268 while (_PyRuntime.nexitfuncs > 0) 2269 (*_PyRuntime.exitfuncs[--_PyRuntime.nexitfuncs])(); 2270 2271 fflush(stdout); 2272 fflush(stderr); 2273 } 2274 2275 void 2276 Py_Exit(int sts) 2277 { 2278 if (Py_FinalizeEx() < 0) { 2279 sts = 120; 2280 } 2281 2282 exit(sts); 2283 } 2284 2285 static _PyInitError 2286 initsigs(void) 2287 { 2288 #ifdef SIGPIPE 2289 PyOS_setsig(SIGPIPE, SIG_IGN); 2290 #endif 2291 #ifdef SIGXFZ 2292 PyOS_setsig(SIGXFZ, SIG_IGN); 2293 #endif 2294 #ifdef SIGXFSZ 2295 PyOS_setsig(SIGXFSZ, SIG_IGN); 2296 #endif 2297 PyOS_InitInterrupts(); /* May imply initsignal() */ 2298 if (PyErr_Occurred()) { 2299 return _Py_INIT_ERR("can't import signal"); 2300 } 2301 return _Py_INIT_OK(); 2302 } 2303 2304 2305 /* Restore signals that the interpreter has called SIG_IGN on to SIG_DFL. 2306 * 2307 * All of the code in this function must only use async-signal-safe functions, 2308 * listed at `man 7 signal` or 2309 * http://www.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html. 2310 */ 2311 void 2312 _Py_RestoreSignals(void) 2313 { 2314 #ifdef SIGPIPE 2315 PyOS_setsig(SIGPIPE, SIG_DFL); 2316 #endif 2317 #ifdef SIGXFZ 2318 PyOS_setsig(SIGXFZ, SIG_DFL); 2319 #endif 2320 #ifdef SIGXFSZ 2321 PyOS_setsig(SIGXFSZ, SIG_DFL); 2322 #endif 2323 } 2324 2325 2326 /* 2327 * The file descriptor fd is considered ``interactive'' if either 2328 * a) isatty(fd) is TRUE, or 2329 * b) the -i flag was given, and the filename associated with 2330 * the descriptor is NULL or "<stdin>" or "???". 2331 */ 2332 int 2333 Py_FdIsInteractive(FILE *fp, const char *filename) 2334 { 2335 if (isatty((int)fileno(fp))) 2336 return 1; 2337 if (!Py_InteractiveFlag) 2338 return 0; 2339 return (filename == NULL) || 2340 (strcmp(filename, "<stdin>") == 0) || 2341 (strcmp(filename, "???") == 0); 2342 } 2343 2344 2345 /* Wrappers around sigaction() or signal(). */ 2346 2347 PyOS_sighandler_t 2348 PyOS_getsig(int sig) 2349 { 2350 #ifdef HAVE_SIGACTION 2351 struct sigaction context; 2352 if (sigaction(sig, NULL, &context) == -1) 2353 return SIG_ERR; 2354 return context.sa_handler; 2355 #else 2356 PyOS_sighandler_t handler; 2357 /* Special signal handling for the secure CRT in Visual Studio 2005 */ 2358 #if defined(_MSC_VER) && _MSC_VER >= 1400 2359 switch (sig) { 2360 /* Only these signals are valid */ 2361 case SIGINT: 2362 case SIGILL: 2363 case SIGFPE: 2364 case SIGSEGV: 2365 case SIGTERM: 2366 case SIGBREAK: 2367 case SIGABRT: 2368 break; 2369 /* Don't call signal() with other values or it will assert */ 2370 default: 2371 return SIG_ERR; 2372 } 2373 #endif /* _MSC_VER && _MSC_VER >= 1400 */ 2374 handler = signal(sig, SIG_IGN); 2375 if (handler != SIG_ERR) 2376 signal(sig, handler); 2377 return handler; 2378 #endif 2379 } 2380 2381 /* 2382 * All of the code in this function must only use async-signal-safe functions, 2383 * listed at `man 7 signal` or 2384 * http://www.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html. 2385 */ 2386 PyOS_sighandler_t 2387 PyOS_setsig(int sig, PyOS_sighandler_t handler) 2388 { 2389 #ifdef HAVE_SIGACTION 2390 /* Some code in Modules/signalmodule.c depends on sigaction() being 2391 * used here if HAVE_SIGACTION is defined. Fix that if this code 2392 * changes to invalidate that assumption. 2393 */ 2394 struct sigaction context, ocontext; 2395 context.sa_handler = handler; 2396 sigemptyset(&context.sa_mask); 2397 context.sa_flags = 0; 2398 if (sigaction(sig, &context, &ocontext) == -1) 2399 return SIG_ERR; 2400 return ocontext.sa_handler; 2401 #else 2402 PyOS_sighandler_t oldhandler; 2403 oldhandler = signal(sig, handler); 2404 #ifdef HAVE_SIGINTERRUPT 2405 siginterrupt(sig, 1); 2406 #endif 2407 return oldhandler; 2408 #endif 2409 } 2410 2411 #ifdef __cplusplus 2412 } 2413 #endif 2414