1 2 /* Python interpreter top-level routines, including init/exit */ 3 4 #include "Python.h" 5 6 #include "Python-ast.h" 7 #undef Yield /* undefine macro conflicting with winbase.h */ 8 #include "grammar.h" 9 #include "node.h" 10 #include "token.h" 11 #include "parsetok.h" 12 #include "errcode.h" 13 #include "code.h" 14 #include "compile.h" 15 #include "symtable.h" 16 #include "pyarena.h" 17 #include "ast.h" 18 #include "eval.h" 19 #include "marshal.h" 20 #include "abstract.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 <locale.h> 32 #include <langinfo.h> 33 #endif 34 35 #ifdef MS_WINDOWS 36 #undef BYTE 37 #include "windows.h" 38 #endif 39 40 #ifndef Py_REF_DEBUG 41 #define PRINT_TOTAL_REFS() 42 #else /* Py_REF_DEBUG */ 43 #define PRINT_TOTAL_REFS() fprintf(stderr, \ 44 "[%" PY_FORMAT_SIZE_T "d refs]\n", \ 45 _Py_GetRefTotal()) 46 #endif 47 48 #ifdef __cplusplus 49 extern "C" { 50 #endif 51 52 extern char *Py_GetPath(void); 53 54 extern grammar _PyParser_Grammar; /* From graminit.c */ 55 56 /* Forward */ 57 static void initmain(void); 58 static void initsite(void); 59 static PyObject *run_mod(mod_ty, const char *, PyObject *, PyObject *, 60 PyCompilerFlags *, PyArena *); 61 static PyObject *run_pyc_file(FILE *, const char *, PyObject *, PyObject *, 62 PyCompilerFlags *); 63 static void err_input(perrdetail *); 64 static void initsigs(void); 65 static void wait_for_thread_shutdown(void); 66 static void call_sys_exitfunc(void); 67 static void call_ll_exitfuncs(void); 68 extern void _PyUnicode_Init(void); 69 extern void _PyUnicode_Fini(void); 70 71 #ifdef WITH_THREAD 72 extern void _PyGILState_Init(PyInterpreterState *, PyThreadState *); 73 extern void _PyGILState_Fini(void); 74 #endif /* WITH_THREAD */ 75 76 int Py_DebugFlag; /* Needed by parser.c */ 77 int Py_VerboseFlag; /* Needed by import.c */ 78 int Py_InteractiveFlag; /* Needed by Py_FdIsInteractive() below */ 79 int Py_InspectFlag; /* Needed to determine whether to exit at SystemExit */ 80 int Py_NoSiteFlag; /* Suppress 'import site' */ 81 int Py_BytesWarningFlag; /* Warn on str(bytes) and str(buffer) */ 82 int Py_DontWriteBytecodeFlag; /* Suppress writing bytecode files (*.py[co]) */ 83 int Py_UseClassExceptionsFlag = 1; /* Needed by bltinmodule.c: deprecated */ 84 int Py_FrozenFlag; /* Needed by getpath.c */ 85 int Py_UnicodeFlag = 0; /* Needed by compile.c */ 86 int Py_IgnoreEnvironmentFlag; /* e.g. PYTHONPATH, PYTHONHOME */ 87 /* _XXX Py_QnewFlag should go away in 2.3. It's true iff -Qnew is passed, 88 on the command line, and is used in 2.2 by ceval.c to make all "/" divisions 89 true divisions (which they will be in 2.3). */ 90 int _Py_QnewFlag = 0; 91 int Py_NoUserSiteDirectory = 0; /* for -s and site.py */ 92 int Py_HashRandomizationFlag = 0; /* for -R and PYTHONHASHSEED */ 93 94 95 /* Hack to force loading of object files */ 96 int (*_PyOS_mystrnicmp_hack)(const char *, const char *, Py_ssize_t) = \ 97 PyOS_mystrnicmp; /* Python/pystrcmp.o */ 98 99 /* PyModule_GetWarningsModule is no longer necessary as of 2.6 100 since _warnings is builtin. This API should not be used. */ 101 PyObject * 102 PyModule_GetWarningsModule(void) 103 { 104 return PyImport_ImportModule("warnings"); 105 } 106 107 static int initialized = 0; 108 109 /* API to access the initialized flag -- useful for esoteric use */ 110 111 int 112 Py_IsInitialized(void) 113 { 114 return initialized; 115 } 116 117 /* Global initializations. Can be undone by Py_Finalize(). Don't 118 call this twice without an intervening Py_Finalize() call. When 119 initializations fail, a fatal error is issued and the function does 120 not return. On return, the first thread and interpreter state have 121 been created. 122 123 Locking: you must hold the interpreter lock while calling this. 124 (If the lock has not yet been initialized, that's equivalent to 125 having the lock, but you cannot use multiple threads.) 126 127 */ 128 129 static int 130 add_flag(int flag, const char *envs) 131 { 132 int env = atoi(envs); 133 if (flag < env) 134 flag = env; 135 if (flag < 1) 136 flag = 1; 137 return flag; 138 } 139 140 static int 141 isatty_no_error(PyObject *sys_stream) 142 { 143 PyObject *sys_isatty = PyObject_CallMethod(sys_stream, "isatty", ""); 144 if (sys_isatty) { 145 int isatty = PyObject_IsTrue(sys_isatty); 146 Py_DECREF(sys_isatty); 147 if (isatty >= 0) 148 return isatty; 149 } 150 PyErr_Clear(); 151 return 0; 152 } 153 154 void 155 Py_InitializeEx(int install_sigs) 156 { 157 PyInterpreterState *interp; 158 PyThreadState *tstate; 159 PyObject *bimod, *sysmod; 160 char *p; 161 char *icodeset = NULL; /* On Windows, input codeset may theoretically 162 differ from output codeset. */ 163 char *codeset = NULL; 164 char *errors = NULL; 165 int free_codeset = 0; 166 int overridden = 0; 167 PyObject *sys_stream; 168 #if defined(Py_USING_UNICODE) && defined(HAVE_LANGINFO_H) && defined(CODESET) 169 char *saved_locale, *loc_codeset; 170 #endif 171 #ifdef MS_WINDOWS 172 char ibuf[128]; 173 char buf[128]; 174 #endif 175 extern void _Py_ReadyTypes(void); 176 177 if (initialized) 178 return; 179 initialized = 1; 180 181 if ((p = Py_GETENV("PYTHONDEBUG")) && *p != '\0') 182 Py_DebugFlag = add_flag(Py_DebugFlag, p); 183 if ((p = Py_GETENV("PYTHONVERBOSE")) && *p != '\0') 184 Py_VerboseFlag = add_flag(Py_VerboseFlag, p); 185 if ((p = Py_GETENV("PYTHONOPTIMIZE")) && *p != '\0') 186 Py_OptimizeFlag = add_flag(Py_OptimizeFlag, p); 187 if ((p = Py_GETENV("PYTHONDONTWRITEBYTECODE")) && *p != '\0') 188 Py_DontWriteBytecodeFlag = add_flag(Py_DontWriteBytecodeFlag, p); 189 /* The variable is only tested for existence here; _PyRandom_Init will 190 check its value further. */ 191 if ((p = Py_GETENV("PYTHONHASHSEED")) && *p != '\0') 192 Py_HashRandomizationFlag = add_flag(Py_HashRandomizationFlag, p); 193 194 _PyRandom_Init(); 195 196 interp = PyInterpreterState_New(); 197 if (interp == NULL) 198 Py_FatalError("Py_Initialize: can't make first interpreter"); 199 200 tstate = PyThreadState_New(interp); 201 if (tstate == NULL) 202 Py_FatalError("Py_Initialize: can't make first thread"); 203 (void) PyThreadState_Swap(tstate); 204 205 _Py_ReadyTypes(); 206 207 if (!_PyFrame_Init()) 208 Py_FatalError("Py_Initialize: can't init frames"); 209 210 if (!_PyInt_Init()) 211 Py_FatalError("Py_Initialize: can't init ints"); 212 213 if (!_PyLong_Init()) 214 Py_FatalError("Py_Initialize: can't init longs"); 215 216 if (!PyByteArray_Init()) 217 Py_FatalError("Py_Initialize: can't init bytearray"); 218 219 _PyFloat_Init(); 220 221 interp->modules = PyDict_New(); 222 if (interp->modules == NULL) 223 Py_FatalError("Py_Initialize: can't make modules dictionary"); 224 interp->modules_reloading = PyDict_New(); 225 if (interp->modules_reloading == NULL) 226 Py_FatalError("Py_Initialize: can't make modules_reloading dictionary"); 227 228 #ifdef Py_USING_UNICODE 229 /* Init Unicode implementation; relies on the codec registry */ 230 _PyUnicode_Init(); 231 #endif 232 233 bimod = _PyBuiltin_Init(); 234 if (bimod == NULL) 235 Py_FatalError("Py_Initialize: can't initialize __builtin__"); 236 interp->builtins = PyModule_GetDict(bimod); 237 if (interp->builtins == NULL) 238 Py_FatalError("Py_Initialize: can't initialize builtins dict"); 239 Py_INCREF(interp->builtins); 240 241 sysmod = _PySys_Init(); 242 if (sysmod == NULL) 243 Py_FatalError("Py_Initialize: can't initialize sys"); 244 interp->sysdict = PyModule_GetDict(sysmod); 245 if (interp->sysdict == NULL) 246 Py_FatalError("Py_Initialize: can't initialize sys dict"); 247 Py_INCREF(interp->sysdict); 248 _PyImport_FixupExtension("sys", "sys"); 249 PySys_SetPath(Py_GetPath()); 250 PyDict_SetItemString(interp->sysdict, "modules", 251 interp->modules); 252 253 _PyImport_Init(); 254 255 /* initialize builtin exceptions */ 256 _PyExc_Init(); 257 _PyImport_FixupExtension("exceptions", "exceptions"); 258 259 /* phase 2 of builtins */ 260 _PyImport_FixupExtension("__builtin__", "__builtin__"); 261 262 _PyImportHooks_Init(); 263 264 if (install_sigs) 265 initsigs(); /* Signal handling stuff, including initintr() */ 266 267 /* Initialize warnings. */ 268 _PyWarnings_Init(); 269 if (PySys_HasWarnOptions()) { 270 PyObject *warnings_module = PyImport_ImportModule("warnings"); 271 if (!warnings_module) 272 PyErr_Clear(); 273 Py_XDECREF(warnings_module); 274 } 275 276 initmain(); /* Module __main__ */ 277 278 /* auto-thread-state API, if available */ 279 #ifdef WITH_THREAD 280 _PyGILState_Init(interp, tstate); 281 #endif /* WITH_THREAD */ 282 283 if (!Py_NoSiteFlag) 284 initsite(); /* Module site */ 285 286 if ((p = Py_GETENV("PYTHONIOENCODING")) && *p != '\0') { 287 p = icodeset = codeset = strdup(p); 288 free_codeset = 1; 289 errors = strchr(p, ':'); 290 if (errors) { 291 *errors = '\0'; 292 errors++; 293 } 294 overridden = 1; 295 } 296 297 #if defined(Py_USING_UNICODE) && defined(HAVE_LANGINFO_H) && defined(CODESET) 298 /* On Unix, set the file system encoding according to the 299 user's preference, if the CODESET names a well-known 300 Python codec, and Py_FileSystemDefaultEncoding isn't 301 initialized by other means. Also set the encoding of 302 stdin and stdout if these are terminals, unless overridden. */ 303 304 if (!overridden || !Py_FileSystemDefaultEncoding) { 305 saved_locale = strdup(setlocale(LC_CTYPE, NULL)); 306 setlocale(LC_CTYPE, ""); 307 loc_codeset = nl_langinfo(CODESET); 308 if (loc_codeset && *loc_codeset) { 309 PyObject *enc = PyCodec_Encoder(loc_codeset); 310 if (enc) { 311 loc_codeset = strdup(loc_codeset); 312 Py_DECREF(enc); 313 } else { 314 if (PyErr_ExceptionMatches(PyExc_LookupError)) { 315 PyErr_Clear(); 316 loc_codeset = NULL; 317 } else { 318 PyErr_Print(); 319 exit(1); 320 } 321 } 322 } else 323 loc_codeset = NULL; 324 setlocale(LC_CTYPE, saved_locale); 325 free(saved_locale); 326 327 if (!overridden) { 328 codeset = icodeset = loc_codeset; 329 free_codeset = 1; 330 } 331 332 /* Initialize Py_FileSystemDefaultEncoding from 333 locale even if PYTHONIOENCODING is set. */ 334 if (!Py_FileSystemDefaultEncoding) { 335 Py_FileSystemDefaultEncoding = loc_codeset; 336 if (!overridden) 337 free_codeset = 0; 338 } 339 } 340 #endif 341 342 #ifdef MS_WINDOWS 343 if (!overridden) { 344 icodeset = ibuf; 345 codeset = buf; 346 sprintf(ibuf, "cp%d", GetConsoleCP()); 347 sprintf(buf, "cp%d", GetConsoleOutputCP()); 348 } 349 #endif 350 351 if (codeset) { 352 sys_stream = PySys_GetObject("stdin"); 353 if ((overridden || isatty_no_error(sys_stream)) && 354 PyFile_Check(sys_stream)) { 355 if (!PyFile_SetEncodingAndErrors(sys_stream, icodeset, errors)) 356 Py_FatalError("Cannot set codeset of stdin"); 357 } 358 359 sys_stream = PySys_GetObject("stdout"); 360 if ((overridden || isatty_no_error(sys_stream)) && 361 PyFile_Check(sys_stream)) { 362 if (!PyFile_SetEncodingAndErrors(sys_stream, codeset, errors)) 363 Py_FatalError("Cannot set codeset of stdout"); 364 } 365 366 sys_stream = PySys_GetObject("stderr"); 367 if ((overridden || isatty_no_error(sys_stream)) && 368 PyFile_Check(sys_stream)) { 369 if (!PyFile_SetEncodingAndErrors(sys_stream, codeset, errors)) 370 Py_FatalError("Cannot set codeset of stderr"); 371 } 372 373 if (free_codeset) 374 free(codeset); 375 } 376 } 377 378 void 379 Py_Initialize(void) 380 { 381 Py_InitializeEx(1); 382 } 383 384 385 #ifdef COUNT_ALLOCS 386 extern void dump_counts(FILE*); 387 #endif 388 389 /* Undo the effect of Py_Initialize(). 390 391 Beware: if multiple interpreter and/or thread states exist, these 392 are not wiped out; only the current thread and interpreter state 393 are deleted. But since everything else is deleted, those other 394 interpreter and thread states should no longer be used. 395 396 (XXX We should do better, e.g. wipe out all interpreters and 397 threads.) 398 399 Locking: as above. 400 401 */ 402 403 void 404 Py_Finalize(void) 405 { 406 PyInterpreterState *interp; 407 PyThreadState *tstate; 408 409 if (!initialized) 410 return; 411 412 wait_for_thread_shutdown(); 413 414 /* The interpreter is still entirely intact at this point, and the 415 * exit funcs may be relying on that. In particular, if some thread 416 * or exit func is still waiting to do an import, the import machinery 417 * expects Py_IsInitialized() to return true. So don't say the 418 * interpreter is uninitialized until after the exit funcs have run. 419 * Note that Threading.py uses an exit func to do a join on all the 420 * threads created thru it, so this also protects pending imports in 421 * the threads created via Threading. 422 */ 423 call_sys_exitfunc(); 424 initialized = 0; 425 426 /* Get current thread state and interpreter pointer */ 427 tstate = PyThreadState_GET(); 428 interp = tstate->interp; 429 430 /* Disable signal handling */ 431 PyOS_FiniInterrupts(); 432 433 /* Clear type lookup cache */ 434 PyType_ClearCache(); 435 436 /* Collect garbage. This may call finalizers; it's nice to call these 437 * before all modules are destroyed. 438 * XXX If a __del__ or weakref callback is triggered here, and tries to 439 * XXX import a module, bad things can happen, because Python no 440 * XXX longer believes it's initialized. 441 * XXX Fatal Python error: Interpreter not initialized (version mismatch?) 442 * XXX is easy to provoke that way. I've also seen, e.g., 443 * XXX Exception exceptions.ImportError: 'No module named sha' 444 * XXX in <function callback at 0x008F5718> ignored 445 * XXX but I'm unclear on exactly how that one happens. In any case, 446 * XXX I haven't seen a real-life report of either of these. 447 */ 448 PyGC_Collect(); 449 #ifdef COUNT_ALLOCS 450 /* With COUNT_ALLOCS, it helps to run GC multiple times: 451 each collection might release some types from the type 452 list, so they become garbage. */ 453 while (PyGC_Collect() > 0) 454 /* nothing */; 455 #endif 456 457 /* Destroy all modules */ 458 PyImport_Cleanup(); 459 460 /* Collect final garbage. This disposes of cycles created by 461 * new-style class definitions, for example. 462 * XXX This is disabled because it caused too many problems. If 463 * XXX a __del__ or weakref callback triggers here, Python code has 464 * XXX a hard time running, because even the sys module has been 465 * XXX cleared out (sys.stdout is gone, sys.excepthook is gone, etc). 466 * XXX One symptom is a sequence of information-free messages 467 * XXX coming from threads (if a __del__ or callback is invoked, 468 * XXX other threads can execute too, and any exception they encounter 469 * XXX triggers a comedy of errors as subsystem after subsystem 470 * XXX fails to find what it *expects* to find in sys to help report 471 * XXX the exception and consequent unexpected failures). I've also 472 * XXX seen segfaults then, after adding print statements to the 473 * XXX Python code getting called. 474 */ 475 #if 0 476 PyGC_Collect(); 477 #endif 478 479 /* Destroy the database used by _PyImport_{Fixup,Find}Extension */ 480 _PyImport_Fini(); 481 482 /* Debugging stuff */ 483 #ifdef COUNT_ALLOCS 484 dump_counts(stdout); 485 #endif 486 487 PRINT_TOTAL_REFS(); 488 489 #ifdef Py_TRACE_REFS 490 /* Display all objects still alive -- this can invoke arbitrary 491 * __repr__ overrides, so requires a mostly-intact interpreter. 492 * Alas, a lot of stuff may still be alive now that will be cleaned 493 * up later. 494 */ 495 if (Py_GETENV("PYTHONDUMPREFS")) 496 _Py_PrintReferences(stderr); 497 #endif /* Py_TRACE_REFS */ 498 499 /* Clear interpreter state */ 500 PyInterpreterState_Clear(interp); 501 502 /* Now we decref the exception classes. After this point nothing 503 can raise an exception. That's okay, because each Fini() method 504 below has been checked to make sure no exceptions are ever 505 raised. 506 */ 507 508 _PyExc_Fini(); 509 510 /* Cleanup auto-thread-state */ 511 #ifdef WITH_THREAD 512 _PyGILState_Fini(); 513 #endif /* WITH_THREAD */ 514 515 /* Delete current thread */ 516 PyThreadState_Swap(NULL); 517 PyInterpreterState_Delete(interp); 518 519 /* Sundry finalizers */ 520 PyMethod_Fini(); 521 PyFrame_Fini(); 522 PyCFunction_Fini(); 523 PyTuple_Fini(); 524 PyList_Fini(); 525 PySet_Fini(); 526 PyString_Fini(); 527 PyByteArray_Fini(); 528 PyInt_Fini(); 529 PyFloat_Fini(); 530 PyDict_Fini(); 531 _PyRandom_Fini(); 532 533 #ifdef Py_USING_UNICODE 534 /* Cleanup Unicode implementation */ 535 _PyUnicode_Fini(); 536 #endif 537 538 /* XXX Still allocated: 539 - various static ad-hoc pointers to interned strings 540 - int and float free list blocks 541 - whatever various modules and libraries allocate 542 */ 543 544 PyGrammar_RemoveAccelerators(&_PyParser_Grammar); 545 546 #ifdef Py_TRACE_REFS 547 /* Display addresses (& refcnts) of all objects still alive. 548 * An address can be used to find the repr of the object, printed 549 * above by _Py_PrintReferences. 550 */ 551 if (Py_GETENV("PYTHONDUMPREFS")) 552 _Py_PrintReferenceAddresses(stderr); 553 #endif /* Py_TRACE_REFS */ 554 #ifdef PYMALLOC_DEBUG 555 if (Py_GETENV("PYTHONMALLOCSTATS")) 556 _PyObject_DebugMallocStats(); 557 #endif 558 559 call_ll_exitfuncs(); 560 } 561 562 /* Create and initialize a new interpreter and thread, and return the 563 new thread. This requires that Py_Initialize() has been called 564 first. 565 566 Unsuccessful initialization yields a NULL pointer. Note that *no* 567 exception information is available even in this case -- the 568 exception information is held in the thread, and there is no 569 thread. 570 571 Locking: as above. 572 573 */ 574 575 PyThreadState * 576 Py_NewInterpreter(void) 577 { 578 PyInterpreterState *interp; 579 PyThreadState *tstate, *save_tstate; 580 PyObject *bimod, *sysmod; 581 582 if (!initialized) 583 Py_FatalError("Py_NewInterpreter: call Py_Initialize first"); 584 585 interp = PyInterpreterState_New(); 586 if (interp == NULL) 587 return NULL; 588 589 tstate = PyThreadState_New(interp); 590 if (tstate == NULL) { 591 PyInterpreterState_Delete(interp); 592 return NULL; 593 } 594 595 save_tstate = PyThreadState_Swap(tstate); 596 597 /* XXX The following is lax in error checking */ 598 599 interp->modules = PyDict_New(); 600 interp->modules_reloading = PyDict_New(); 601 602 bimod = _PyImport_FindExtension("__builtin__", "__builtin__"); 603 if (bimod != NULL) { 604 interp->builtins = PyModule_GetDict(bimod); 605 if (interp->builtins == NULL) 606 goto handle_error; 607 Py_INCREF(interp->builtins); 608 } 609 sysmod = _PyImport_FindExtension("sys", "sys"); 610 if (bimod != NULL && sysmod != NULL) { 611 interp->sysdict = PyModule_GetDict(sysmod); 612 if (interp->sysdict == NULL) 613 goto handle_error; 614 Py_INCREF(interp->sysdict); 615 PySys_SetPath(Py_GetPath()); 616 PyDict_SetItemString(interp->sysdict, "modules", 617 interp->modules); 618 _PyImportHooks_Init(); 619 initmain(); 620 if (!Py_NoSiteFlag) 621 initsite(); 622 } 623 624 if (!PyErr_Occurred()) 625 return tstate; 626 627 handle_error: 628 /* Oops, it didn't work. Undo it all. */ 629 630 PyErr_Print(); 631 PyThreadState_Clear(tstate); 632 PyThreadState_Swap(save_tstate); 633 PyThreadState_Delete(tstate); 634 PyInterpreterState_Delete(interp); 635 636 return NULL; 637 } 638 639 /* Delete an interpreter and its last thread. This requires that the 640 given thread state is current, that the thread has no remaining 641 frames, and that it is its interpreter's only remaining thread. 642 It is a fatal error to violate these constraints. 643 644 (Py_Finalize() doesn't have these constraints -- it zaps 645 everything, regardless.) 646 647 Locking: as above. 648 649 */ 650 651 void 652 Py_EndInterpreter(PyThreadState *tstate) 653 { 654 PyInterpreterState *interp = tstate->interp; 655 656 if (tstate != PyThreadState_GET()) 657 Py_FatalError("Py_EndInterpreter: thread is not current"); 658 if (tstate->frame != NULL) 659 Py_FatalError("Py_EndInterpreter: thread still has a frame"); 660 if (tstate != interp->tstate_head || tstate->next != NULL) 661 Py_FatalError("Py_EndInterpreter: not the last thread"); 662 663 PyImport_Cleanup(); 664 PyInterpreterState_Clear(interp); 665 PyThreadState_Swap(NULL); 666 PyInterpreterState_Delete(interp); 667 } 668 669 static char *progname = "python"; 670 671 void 672 Py_SetProgramName(char *pn) 673 { 674 if (pn && *pn) 675 progname = pn; 676 } 677 678 char * 679 Py_GetProgramName(void) 680 { 681 return progname; 682 } 683 684 static char *default_home = NULL; 685 686 void 687 Py_SetPythonHome(char *home) 688 { 689 default_home = home; 690 } 691 692 char * 693 Py_GetPythonHome(void) 694 { 695 char *home = default_home; 696 if (home == NULL && !Py_IgnoreEnvironmentFlag) 697 home = Py_GETENV("PYTHONHOME"); 698 return home; 699 } 700 701 /* Create __main__ module */ 702 703 static void 704 initmain(void) 705 { 706 PyObject *m, *d; 707 m = PyImport_AddModule("__main__"); 708 if (m == NULL) 709 Py_FatalError("can't create __main__ module"); 710 d = PyModule_GetDict(m); 711 if (PyDict_GetItemString(d, "__builtins__") == NULL) { 712 PyObject *bimod = PyImport_ImportModule("__builtin__"); 713 if (bimod == NULL || 714 PyDict_SetItemString(d, "__builtins__", bimod) != 0) 715 Py_FatalError("can't add __builtins__ to __main__"); 716 Py_XDECREF(bimod); 717 } 718 } 719 720 /* Import the site module (not into __main__ though) */ 721 722 static void 723 initsite(void) 724 { 725 PyObject *m; 726 m = PyImport_ImportModule("site"); 727 if (m == NULL) { 728 PyErr_Print(); 729 Py_Finalize(); 730 exit(1); 731 } 732 else { 733 Py_DECREF(m); 734 } 735 } 736 737 /* Parse input from a file and execute it */ 738 739 int 740 PyRun_AnyFileExFlags(FILE *fp, const char *filename, int closeit, 741 PyCompilerFlags *flags) 742 { 743 if (filename == NULL) 744 filename = "???"; 745 if (Py_FdIsInteractive(fp, filename)) { 746 int err = PyRun_InteractiveLoopFlags(fp, filename, flags); 747 if (closeit) 748 fclose(fp); 749 return err; 750 } 751 else 752 return PyRun_SimpleFileExFlags(fp, filename, closeit, flags); 753 } 754 755 int 756 PyRun_InteractiveLoopFlags(FILE *fp, const char *filename, PyCompilerFlags *flags) 757 { 758 PyObject *v; 759 int ret; 760 PyCompilerFlags local_flags; 761 762 if (flags == NULL) { 763 flags = &local_flags; 764 local_flags.cf_flags = 0; 765 } 766 v = PySys_GetObject("ps1"); 767 if (v == NULL) { 768 PySys_SetObject("ps1", v = PyString_FromString(">>> ")); 769 Py_XDECREF(v); 770 } 771 v = PySys_GetObject("ps2"); 772 if (v == NULL) { 773 PySys_SetObject("ps2", v = PyString_FromString("... ")); 774 Py_XDECREF(v); 775 } 776 for (;;) { 777 ret = PyRun_InteractiveOneFlags(fp, filename, flags); 778 PRINT_TOTAL_REFS(); 779 if (ret == E_EOF) 780 return 0; 781 /* 782 if (ret == E_NOMEM) 783 return -1; 784 */ 785 } 786 } 787 788 #if 0 789 /* compute parser flags based on compiler flags */ 790 #define PARSER_FLAGS(flags) \ 791 ((flags) ? ((((flags)->cf_flags & PyCF_DONT_IMPLY_DEDENT) ? \ 792 PyPARSE_DONT_IMPLY_DEDENT : 0)) : 0) 793 #endif 794 #if 1 795 /* Keep an example of flags with future keyword support. */ 796 #define PARSER_FLAGS(flags) \ 797 ((flags) ? ((((flags)->cf_flags & PyCF_DONT_IMPLY_DEDENT) ? \ 798 PyPARSE_DONT_IMPLY_DEDENT : 0) \ 799 | (((flags)->cf_flags & CO_FUTURE_PRINT_FUNCTION) ? \ 800 PyPARSE_PRINT_IS_FUNCTION : 0) \ 801 | (((flags)->cf_flags & CO_FUTURE_UNICODE_LITERALS) ? \ 802 PyPARSE_UNICODE_LITERALS : 0) \ 803 ) : 0) 804 #endif 805 806 int 807 PyRun_InteractiveOneFlags(FILE *fp, const char *filename, PyCompilerFlags *flags) 808 { 809 PyObject *m, *d, *v, *w; 810 mod_ty mod; 811 PyArena *arena; 812 char *ps1 = "", *ps2 = ""; 813 int errcode = 0; 814 815 v = PySys_GetObject("ps1"); 816 if (v != NULL) { 817 v = PyObject_Str(v); 818 if (v == NULL) 819 PyErr_Clear(); 820 else if (PyString_Check(v)) 821 ps1 = PyString_AsString(v); 822 } 823 w = PySys_GetObject("ps2"); 824 if (w != NULL) { 825 w = PyObject_Str(w); 826 if (w == NULL) 827 PyErr_Clear(); 828 else if (PyString_Check(w)) 829 ps2 = PyString_AsString(w); 830 } 831 arena = PyArena_New(); 832 if (arena == NULL) { 833 Py_XDECREF(v); 834 Py_XDECREF(w); 835 return -1; 836 } 837 mod = PyParser_ASTFromFile(fp, filename, 838 Py_single_input, ps1, ps2, 839 flags, &errcode, arena); 840 Py_XDECREF(v); 841 Py_XDECREF(w); 842 if (mod == NULL) { 843 PyArena_Free(arena); 844 if (errcode == E_EOF) { 845 PyErr_Clear(); 846 return E_EOF; 847 } 848 PyErr_Print(); 849 return -1; 850 } 851 m = PyImport_AddModule("__main__"); 852 if (m == NULL) { 853 PyArena_Free(arena); 854 return -1; 855 } 856 d = PyModule_GetDict(m); 857 v = run_mod(mod, filename, d, d, flags, arena); 858 PyArena_Free(arena); 859 if (v == NULL) { 860 PyErr_Print(); 861 return -1; 862 } 863 Py_DECREF(v); 864 if (Py_FlushLine()) 865 PyErr_Clear(); 866 return 0; 867 } 868 869 /* Check whether a file maybe a pyc file: Look at the extension, 870 the file type, and, if we may close it, at the first few bytes. */ 871 872 static int 873 maybe_pyc_file(FILE *fp, const char* filename, const char* ext, int closeit) 874 { 875 if (strcmp(ext, ".pyc") == 0 || strcmp(ext, ".pyo") == 0) 876 return 1; 877 878 /* Only look into the file if we are allowed to close it, since 879 it then should also be seekable. */ 880 if (closeit) { 881 /* Read only two bytes of the magic. If the file was opened in 882 text mode, the bytes 3 and 4 of the magic (\r\n) might not 883 be read as they are on disk. */ 884 unsigned int halfmagic = PyImport_GetMagicNumber() & 0xFFFF; 885 unsigned char buf[2]; 886 /* Mess: In case of -x, the stream is NOT at its start now, 887 and ungetc() was used to push back the first newline, 888 which makes the current stream position formally undefined, 889 and a x-platform nightmare. 890 Unfortunately, we have no direct way to know whether -x 891 was specified. So we use a terrible hack: if the current 892 stream position is not 0, we assume -x was specified, and 893 give up. Bug 132850 on SourceForge spells out the 894 hopelessness of trying anything else (fseek and ftell 895 don't work predictably x-platform for text-mode files). 896 */ 897 int ispyc = 0; 898 if (ftell(fp) == 0) { 899 if (fread(buf, 1, 2, fp) == 2 && 900 ((unsigned int)buf[1]<<8 | buf[0]) == halfmagic) 901 ispyc = 1; 902 rewind(fp); 903 } 904 return ispyc; 905 } 906 return 0; 907 } 908 909 int 910 PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit, 911 PyCompilerFlags *flags) 912 { 913 PyObject *m, *d, *v; 914 const char *ext; 915 int set_file_name = 0, len, ret = -1; 916 917 m = PyImport_AddModule("__main__"); 918 if (m == NULL) 919 return -1; 920 Py_INCREF(m); 921 d = PyModule_GetDict(m); 922 if (PyDict_GetItemString(d, "__file__") == NULL) { 923 PyObject *f = PyString_FromString(filename); 924 if (f == NULL) 925 goto done; 926 if (PyDict_SetItemString(d, "__file__", f) < 0) { 927 Py_DECREF(f); 928 goto done; 929 } 930 set_file_name = 1; 931 Py_DECREF(f); 932 } 933 len = strlen(filename); 934 ext = filename + len - (len > 4 ? 4 : 0); 935 if (maybe_pyc_file(fp, filename, ext, closeit)) { 936 /* Try to run a pyc file. First, re-open in binary */ 937 if (closeit) 938 fclose(fp); 939 if ((fp = fopen(filename, "rb")) == NULL) { 940 fprintf(stderr, "python: Can't reopen .pyc file\n"); 941 goto done; 942 } 943 /* Turn on optimization if a .pyo file is given */ 944 if (strcmp(ext, ".pyo") == 0) 945 Py_OptimizeFlag = 1; 946 v = run_pyc_file(fp, filename, d, d, flags); 947 } else { 948 v = PyRun_FileExFlags(fp, filename, Py_file_input, d, d, 949 closeit, flags); 950 } 951 if (v == NULL) { 952 PyErr_Print(); 953 goto done; 954 } 955 Py_DECREF(v); 956 if (Py_FlushLine()) 957 PyErr_Clear(); 958 ret = 0; 959 done: 960 if (set_file_name && PyDict_DelItemString(d, "__file__")) 961 PyErr_Clear(); 962 Py_DECREF(m); 963 return ret; 964 } 965 966 int 967 PyRun_SimpleStringFlags(const char *command, PyCompilerFlags *flags) 968 { 969 PyObject *m, *d, *v; 970 m = PyImport_AddModule("__main__"); 971 if (m == NULL) 972 return -1; 973 d = PyModule_GetDict(m); 974 v = PyRun_StringFlags(command, Py_file_input, d, d, flags); 975 if (v == NULL) { 976 PyErr_Print(); 977 return -1; 978 } 979 Py_DECREF(v); 980 if (Py_FlushLine()) 981 PyErr_Clear(); 982 return 0; 983 } 984 985 static int 986 parse_syntax_error(PyObject *err, PyObject **message, const char **filename, 987 int *lineno, int *offset, const char **text) 988 { 989 long hold; 990 PyObject *v; 991 992 /* old style errors */ 993 if (PyTuple_Check(err)) 994 return PyArg_ParseTuple(err, "O(ziiz)", message, filename, 995 lineno, offset, text); 996 997 *message = NULL; 998 999 /* new style errors. `err' is an instance */ 1000 *message = PyObject_GetAttrString(err, "msg"); 1001 if (!*message) 1002 goto finally; 1003 1004 v = PyObject_GetAttrString(err, "filename"); 1005 if (!v) 1006 goto finally; 1007 if (v == Py_None) { 1008 Py_DECREF(v); 1009 *filename = NULL; 1010 } 1011 else { 1012 *filename = PyString_AsString(v); 1013 Py_DECREF(v); 1014 if (!*filename) 1015 goto finally; 1016 } 1017 1018 v = PyObject_GetAttrString(err, "lineno"); 1019 if (!v) 1020 goto finally; 1021 hold = PyInt_AsLong(v); 1022 Py_DECREF(v); 1023 if (hold < 0 && PyErr_Occurred()) 1024 goto finally; 1025 *lineno = (int)hold; 1026 1027 v = PyObject_GetAttrString(err, "offset"); 1028 if (!v) 1029 goto finally; 1030 if (v == Py_None) { 1031 *offset = -1; 1032 Py_DECREF(v); 1033 } else { 1034 hold = PyInt_AsLong(v); 1035 Py_DECREF(v); 1036 if (hold < 0 && PyErr_Occurred()) 1037 goto finally; 1038 *offset = (int)hold; 1039 } 1040 1041 v = PyObject_GetAttrString(err, "text"); 1042 if (!v) 1043 goto finally; 1044 if (v == Py_None) { 1045 Py_DECREF(v); 1046 *text = NULL; 1047 } 1048 else { 1049 *text = PyString_AsString(v); 1050 Py_DECREF(v); 1051 if (!*text) 1052 goto finally; 1053 } 1054 return 1; 1055 1056 finally: 1057 Py_XDECREF(*message); 1058 return 0; 1059 } 1060 1061 void 1062 PyErr_Print(void) 1063 { 1064 PyErr_PrintEx(1); 1065 } 1066 1067 static void 1068 print_error_text(PyObject *f, int offset, const char *text) 1069 { 1070 char *nl; 1071 if (offset >= 0) { 1072 if (offset > 0 && offset == strlen(text) && text[offset - 1] == '\n') 1073 offset--; 1074 for (;;) { 1075 nl = strchr(text, '\n'); 1076 if (nl == NULL || nl-text >= offset) 1077 break; 1078 offset -= (int)(nl+1-text); 1079 text = nl+1; 1080 } 1081 while (*text == ' ' || *text == '\t') { 1082 text++; 1083 offset--; 1084 } 1085 } 1086 PyFile_WriteString(" ", f); 1087 PyFile_WriteString(text, f); 1088 if (*text == '\0' || text[strlen(text)-1] != '\n') 1089 PyFile_WriteString("\n", f); 1090 if (offset == -1) 1091 return; 1092 PyFile_WriteString(" ", f); 1093 offset--; 1094 while (offset > 0) { 1095 PyFile_WriteString(" ", f); 1096 offset--; 1097 } 1098 PyFile_WriteString("^\n", f); 1099 } 1100 1101 static void 1102 handle_system_exit(void) 1103 { 1104 PyObject *exception, *value, *tb; 1105 int exitcode = 0; 1106 1107 if (Py_InspectFlag) 1108 /* Don't exit if -i flag was given. This flag is set to 0 1109 * when entering interactive mode for inspecting. */ 1110 return; 1111 1112 PyErr_Fetch(&exception, &value, &tb); 1113 if (Py_FlushLine()) 1114 PyErr_Clear(); 1115 fflush(stdout); 1116 if (value == NULL || value == Py_None) 1117 goto done; 1118 if (PyExceptionInstance_Check(value)) { 1119 /* The error code should be in the `code' attribute. */ 1120 PyObject *code = PyObject_GetAttrString(value, "code"); 1121 if (code) { 1122 Py_DECREF(value); 1123 value = code; 1124 if (value == Py_None) 1125 goto done; 1126 } 1127 /* If we failed to dig out the 'code' attribute, 1128 just let the else clause below print the error. */ 1129 } 1130 if (PyInt_Check(value)) 1131 exitcode = (int)PyInt_AsLong(value); 1132 else { 1133 PyObject *sys_stderr = PySys_GetObject("stderr"); 1134 if (sys_stderr != NULL && sys_stderr != Py_None) { 1135 PyFile_WriteObject(value, sys_stderr, Py_PRINT_RAW); 1136 } else { 1137 PyObject_Print(value, stderr, Py_PRINT_RAW); 1138 fflush(stderr); 1139 } 1140 PySys_WriteStderr("\n"); 1141 exitcode = 1; 1142 } 1143 done: 1144 /* Restore and clear the exception info, in order to properly decref 1145 * the exception, value, and traceback. If we just exit instead, 1146 * these leak, which confuses PYTHONDUMPREFS output, and may prevent 1147 * some finalizers from running. 1148 */ 1149 PyErr_Restore(exception, value, tb); 1150 PyErr_Clear(); 1151 Py_Exit(exitcode); 1152 /* NOTREACHED */ 1153 } 1154 1155 void 1156 PyErr_PrintEx(int set_sys_last_vars) 1157 { 1158 PyObject *exception, *v, *tb, *hook; 1159 1160 if (PyErr_ExceptionMatches(PyExc_SystemExit)) { 1161 handle_system_exit(); 1162 } 1163 PyErr_Fetch(&exception, &v, &tb); 1164 if (exception == NULL) 1165 return; 1166 PyErr_NormalizeException(&exception, &v, &tb); 1167 if (exception == NULL) 1168 return; 1169 /* Now we know v != NULL too */ 1170 if (set_sys_last_vars) { 1171 PySys_SetObject("last_type", exception); 1172 PySys_SetObject("last_value", v); 1173 PySys_SetObject("last_traceback", tb); 1174 } 1175 hook = PySys_GetObject("excepthook"); 1176 if (hook && hook != Py_None) { 1177 PyObject *args = PyTuple_Pack(3, 1178 exception, v, tb ? tb : Py_None); 1179 PyObject *result = PyEval_CallObject(hook, args); 1180 if (result == NULL) { 1181 PyObject *exception2, *v2, *tb2; 1182 if (PyErr_ExceptionMatches(PyExc_SystemExit)) { 1183 handle_system_exit(); 1184 } 1185 PyErr_Fetch(&exception2, &v2, &tb2); 1186 PyErr_NormalizeException(&exception2, &v2, &tb2); 1187 /* It should not be possible for exception2 or v2 1188 to be NULL. However PyErr_Display() can't 1189 tolerate NULLs, so just be safe. */ 1190 if (exception2 == NULL) { 1191 exception2 = Py_None; 1192 Py_INCREF(exception2); 1193 } 1194 if (v2 == NULL) { 1195 v2 = Py_None; 1196 Py_INCREF(v2); 1197 } 1198 if (Py_FlushLine()) 1199 PyErr_Clear(); 1200 fflush(stdout); 1201 PySys_WriteStderr("Error in sys.excepthook:\n"); 1202 PyErr_Display(exception2, v2, tb2); 1203 PySys_WriteStderr("\nOriginal exception was:\n"); 1204 PyErr_Display(exception, v, tb); 1205 Py_DECREF(exception2); 1206 Py_DECREF(v2); 1207 Py_XDECREF(tb2); 1208 } 1209 Py_XDECREF(result); 1210 Py_XDECREF(args); 1211 } else { 1212 PySys_WriteStderr("sys.excepthook is missing\n"); 1213 PyErr_Display(exception, v, tb); 1214 } 1215 Py_XDECREF(exception); 1216 Py_XDECREF(v); 1217 Py_XDECREF(tb); 1218 } 1219 1220 void 1221 PyErr_Display(PyObject *exception, PyObject *value, PyObject *tb) 1222 { 1223 int err = 0; 1224 PyObject *f = PySys_GetObject("stderr"); 1225 Py_INCREF(value); 1226 if (f == NULL || f == Py_None) 1227 fprintf(stderr, "lost sys.stderr\n"); 1228 else { 1229 if (Py_FlushLine()) 1230 PyErr_Clear(); 1231 fflush(stdout); 1232 if (tb && tb != Py_None) 1233 err = PyTraceBack_Print(tb, f); 1234 if (err == 0 && 1235 PyObject_HasAttrString(value, "print_file_and_line")) 1236 { 1237 PyObject *message; 1238 const char *filename, *text; 1239 int lineno, offset; 1240 if (!parse_syntax_error(value, &message, &filename, 1241 &lineno, &offset, &text)) 1242 PyErr_Clear(); 1243 else { 1244 char buf[10]; 1245 PyFile_WriteString(" File \"", f); 1246 if (filename == NULL) 1247 PyFile_WriteString("<string>", f); 1248 else 1249 PyFile_WriteString(filename, f); 1250 PyFile_WriteString("\", line ", f); 1251 PyOS_snprintf(buf, sizeof(buf), "%d", lineno); 1252 PyFile_WriteString(buf, f); 1253 PyFile_WriteString("\n", f); 1254 if (text != NULL) 1255 print_error_text(f, offset, text); 1256 Py_DECREF(value); 1257 value = message; 1258 /* Can't be bothered to check all those 1259 PyFile_WriteString() calls */ 1260 if (PyErr_Occurred()) 1261 err = -1; 1262 } 1263 } 1264 if (err) { 1265 /* Don't do anything else */ 1266 } 1267 else if (PyExceptionClass_Check(exception)) { 1268 PyObject* moduleName; 1269 char* className = PyExceptionClass_Name(exception); 1270 if (className != NULL) { 1271 char *dot = strrchr(className, '.'); 1272 if (dot != NULL) 1273 className = dot+1; 1274 } 1275 1276 moduleName = PyObject_GetAttrString(exception, "__module__"); 1277 if (moduleName == NULL) 1278 err = PyFile_WriteString("<unknown>", f); 1279 else { 1280 char* modstr = PyString_AsString(moduleName); 1281 if (modstr && strcmp(modstr, "exceptions")) 1282 { 1283 err = PyFile_WriteString(modstr, f); 1284 err += PyFile_WriteString(".", f); 1285 } 1286 Py_DECREF(moduleName); 1287 } 1288 if (err == 0) { 1289 if (className == NULL) 1290 err = PyFile_WriteString("<unknown>", f); 1291 else 1292 err = PyFile_WriteString(className, f); 1293 } 1294 } 1295 else 1296 err = PyFile_WriteObject(exception, f, Py_PRINT_RAW); 1297 if (err == 0 && (value != Py_None)) { 1298 PyObject *s = PyObject_Str(value); 1299 /* only print colon if the str() of the 1300 object is not the empty string 1301 */ 1302 if (s == NULL) { 1303 PyErr_Clear(); 1304 err = -1; 1305 PyFile_WriteString(": <exception str() failed>", f); 1306 } 1307 else if (!PyString_Check(s) || 1308 PyString_GET_SIZE(s) != 0) 1309 err = PyFile_WriteString(": ", f); 1310 if (err == 0) 1311 err = PyFile_WriteObject(s, f, Py_PRINT_RAW); 1312 Py_XDECREF(s); 1313 } 1314 /* try to write a newline in any case */ 1315 if (err < 0) { 1316 PyErr_Clear(); 1317 } 1318 err += PyFile_WriteString("\n", f); 1319 } 1320 Py_DECREF(value); 1321 /* If an error happened here, don't show it. 1322 XXX This is wrong, but too many callers rely on this behavior. */ 1323 if (err != 0) 1324 PyErr_Clear(); 1325 } 1326 1327 PyObject * 1328 PyRun_StringFlags(const char *str, int start, PyObject *globals, 1329 PyObject *locals, PyCompilerFlags *flags) 1330 { 1331 PyObject *ret = NULL; 1332 mod_ty mod; 1333 PyArena *arena = PyArena_New(); 1334 if (arena == NULL) 1335 return NULL; 1336 1337 mod = PyParser_ASTFromString(str, "<string>", start, flags, arena); 1338 if (mod != NULL) 1339 ret = run_mod(mod, "<string>", globals, locals, flags, arena); 1340 PyArena_Free(arena); 1341 return ret; 1342 } 1343 1344 PyObject * 1345 PyRun_FileExFlags(FILE *fp, const char *filename, int start, PyObject *globals, 1346 PyObject *locals, int closeit, PyCompilerFlags *flags) 1347 { 1348 PyObject *ret; 1349 mod_ty mod; 1350 PyArena *arena = PyArena_New(); 1351 if (arena == NULL) 1352 return NULL; 1353 1354 mod = PyParser_ASTFromFile(fp, filename, start, 0, 0, 1355 flags, NULL, arena); 1356 if (closeit) 1357 fclose(fp); 1358 if (mod == NULL) { 1359 PyArena_Free(arena); 1360 return NULL; 1361 } 1362 ret = run_mod(mod, filename, globals, locals, flags, arena); 1363 PyArena_Free(arena); 1364 return ret; 1365 } 1366 1367 static PyObject * 1368 run_mod(mod_ty mod, const char *filename, PyObject *globals, PyObject *locals, 1369 PyCompilerFlags *flags, PyArena *arena) 1370 { 1371 PyCodeObject *co; 1372 PyObject *v; 1373 co = PyAST_Compile(mod, filename, flags, arena); 1374 if (co == NULL) 1375 return NULL; 1376 v = PyEval_EvalCode(co, globals, locals); 1377 Py_DECREF(co); 1378 return v; 1379 } 1380 1381 static PyObject * 1382 run_pyc_file(FILE *fp, const char *filename, PyObject *globals, 1383 PyObject *locals, PyCompilerFlags *flags) 1384 { 1385 PyCodeObject *co; 1386 PyObject *v; 1387 long magic; 1388 long PyImport_GetMagicNumber(void); 1389 1390 magic = PyMarshal_ReadLongFromFile(fp); 1391 if (magic != PyImport_GetMagicNumber()) { 1392 PyErr_SetString(PyExc_RuntimeError, 1393 "Bad magic number in .pyc file"); 1394 return NULL; 1395 } 1396 (void) PyMarshal_ReadLongFromFile(fp); 1397 v = PyMarshal_ReadLastObjectFromFile(fp); 1398 fclose(fp); 1399 if (v == NULL || !PyCode_Check(v)) { 1400 Py_XDECREF(v); 1401 PyErr_SetString(PyExc_RuntimeError, 1402 "Bad code object in .pyc file"); 1403 return NULL; 1404 } 1405 co = (PyCodeObject *)v; 1406 v = PyEval_EvalCode(co, globals, locals); 1407 if (v && flags) 1408 flags->cf_flags |= (co->co_flags & PyCF_MASK); 1409 Py_DECREF(co); 1410 return v; 1411 } 1412 1413 PyObject * 1414 Py_CompileStringFlags(const char *str, const char *filename, int start, 1415 PyCompilerFlags *flags) 1416 { 1417 PyCodeObject *co; 1418 mod_ty mod; 1419 PyArena *arena = PyArena_New(); 1420 if (arena == NULL) 1421 return NULL; 1422 1423 mod = PyParser_ASTFromString(str, filename, start, flags, arena); 1424 if (mod == NULL) { 1425 PyArena_Free(arena); 1426 return NULL; 1427 } 1428 if (flags && (flags->cf_flags & PyCF_ONLY_AST)) { 1429 PyObject *result = PyAST_mod2obj(mod); 1430 PyArena_Free(arena); 1431 return result; 1432 } 1433 co = PyAST_Compile(mod, filename, flags, arena); 1434 PyArena_Free(arena); 1435 return (PyObject *)co; 1436 } 1437 1438 struct symtable * 1439 Py_SymtableString(const char *str, const char *filename, int start) 1440 { 1441 struct symtable *st; 1442 mod_ty mod; 1443 PyCompilerFlags flags; 1444 PyArena *arena = PyArena_New(); 1445 if (arena == NULL) 1446 return NULL; 1447 1448 flags.cf_flags = 0; 1449 1450 mod = PyParser_ASTFromString(str, filename, start, &flags, arena); 1451 if (mod == NULL) { 1452 PyArena_Free(arena); 1453 return NULL; 1454 } 1455 st = PySymtable_Build(mod, filename, 0); 1456 PyArena_Free(arena); 1457 return st; 1458 } 1459 1460 /* Preferred access to parser is through AST. */ 1461 mod_ty 1462 PyParser_ASTFromString(const char *s, const char *filename, int start, 1463 PyCompilerFlags *flags, PyArena *arena) 1464 { 1465 mod_ty mod; 1466 PyCompilerFlags localflags; 1467 perrdetail err; 1468 int iflags = PARSER_FLAGS(flags); 1469 1470 node *n = PyParser_ParseStringFlagsFilenameEx(s, filename, 1471 &_PyParser_Grammar, start, &err, 1472 &iflags); 1473 if (flags == NULL) { 1474 localflags.cf_flags = 0; 1475 flags = &localflags; 1476 } 1477 if (n) { 1478 flags->cf_flags |= iflags & PyCF_MASK; 1479 mod = PyAST_FromNode(n, flags, filename, arena); 1480 PyNode_Free(n); 1481 return mod; 1482 } 1483 else { 1484 err_input(&err); 1485 return NULL; 1486 } 1487 } 1488 1489 mod_ty 1490 PyParser_ASTFromFile(FILE *fp, const char *filename, int start, char *ps1, 1491 char *ps2, PyCompilerFlags *flags, int *errcode, 1492 PyArena *arena) 1493 { 1494 mod_ty mod; 1495 PyCompilerFlags localflags; 1496 perrdetail err; 1497 int iflags = PARSER_FLAGS(flags); 1498 1499 node *n = PyParser_ParseFileFlagsEx(fp, filename, &_PyParser_Grammar, 1500 start, ps1, ps2, &err, &iflags); 1501 if (flags == NULL) { 1502 localflags.cf_flags = 0; 1503 flags = &localflags; 1504 } 1505 if (n) { 1506 flags->cf_flags |= iflags & PyCF_MASK; 1507 mod = PyAST_FromNode(n, flags, filename, arena); 1508 PyNode_Free(n); 1509 return mod; 1510 } 1511 else { 1512 err_input(&err); 1513 if (errcode) 1514 *errcode = err.error; 1515 return NULL; 1516 } 1517 } 1518 1519 /* Simplified interface to parsefile -- return node or set exception */ 1520 1521 node * 1522 PyParser_SimpleParseFileFlags(FILE *fp, const char *filename, int start, int flags) 1523 { 1524 perrdetail err; 1525 node *n = PyParser_ParseFileFlags(fp, filename, &_PyParser_Grammar, 1526 start, NULL, NULL, &err, flags); 1527 if (n == NULL) 1528 err_input(&err); 1529 1530 return n; 1531 } 1532 1533 /* Simplified interface to parsestring -- return node or set exception */ 1534 1535 node * 1536 PyParser_SimpleParseStringFlags(const char *str, int start, int flags) 1537 { 1538 perrdetail err; 1539 node *n = PyParser_ParseStringFlags(str, &_PyParser_Grammar, 1540 start, &err, flags); 1541 if (n == NULL) 1542 err_input(&err); 1543 return n; 1544 } 1545 1546 node * 1547 PyParser_SimpleParseStringFlagsFilename(const char *str, const char *filename, 1548 int start, int flags) 1549 { 1550 perrdetail err; 1551 node *n = PyParser_ParseStringFlagsFilename(str, filename, 1552 &_PyParser_Grammar, start, &err, flags); 1553 if (n == NULL) 1554 err_input(&err); 1555 return n; 1556 } 1557 1558 node * 1559 PyParser_SimpleParseStringFilename(const char *str, const char *filename, int start) 1560 { 1561 return PyParser_SimpleParseStringFlagsFilename(str, filename, start, 0); 1562 } 1563 1564 /* May want to move a more generalized form of this to parsetok.c or 1565 even parser modules. */ 1566 1567 void 1568 PyParser_SetError(perrdetail *err) 1569 { 1570 err_input(err); 1571 } 1572 1573 /* Set the error appropriate to the given input error code (see errcode.h) */ 1574 1575 static void 1576 err_input(perrdetail *err) 1577 { 1578 PyObject *v, *w, *errtype; 1579 PyObject* u = NULL; 1580 char *msg = NULL; 1581 errtype = PyExc_SyntaxError; 1582 switch (err->error) { 1583 case E_ERROR: 1584 return; 1585 case E_SYNTAX: 1586 errtype = PyExc_IndentationError; 1587 if (err->expected == INDENT) 1588 msg = "expected an indented block"; 1589 else if (err->token == INDENT) 1590 msg = "unexpected indent"; 1591 else if (err->token == DEDENT) 1592 msg = "unexpected unindent"; 1593 else { 1594 errtype = PyExc_SyntaxError; 1595 msg = "invalid syntax"; 1596 } 1597 break; 1598 case E_TOKEN: 1599 msg = "invalid token"; 1600 break; 1601 case E_EOFS: 1602 msg = "EOF while scanning triple-quoted string literal"; 1603 break; 1604 case E_EOLS: 1605 msg = "EOL while scanning string literal"; 1606 break; 1607 case E_INTR: 1608 if (!PyErr_Occurred()) 1609 PyErr_SetNone(PyExc_KeyboardInterrupt); 1610 goto cleanup; 1611 case E_NOMEM: 1612 PyErr_NoMemory(); 1613 goto cleanup; 1614 case E_EOF: 1615 msg = "unexpected EOF while parsing"; 1616 break; 1617 case E_TABSPACE: 1618 errtype = PyExc_TabError; 1619 msg = "inconsistent use of tabs and spaces in indentation"; 1620 break; 1621 case E_OVERFLOW: 1622 msg = "expression too long"; 1623 break; 1624 case E_DEDENT: 1625 errtype = PyExc_IndentationError; 1626 msg = "unindent does not match any outer indentation level"; 1627 break; 1628 case E_TOODEEP: 1629 errtype = PyExc_IndentationError; 1630 msg = "too many levels of indentation"; 1631 break; 1632 case E_DECODE: { 1633 PyObject *type, *value, *tb; 1634 PyErr_Fetch(&type, &value, &tb); 1635 if (value != NULL) { 1636 u = PyObject_Str(value); 1637 if (u != NULL) { 1638 msg = PyString_AsString(u); 1639 } 1640 } 1641 if (msg == NULL) 1642 msg = "unknown decode error"; 1643 Py_XDECREF(type); 1644 Py_XDECREF(value); 1645 Py_XDECREF(tb); 1646 break; 1647 } 1648 case E_LINECONT: 1649 msg = "unexpected character after line continuation character"; 1650 break; 1651 default: 1652 fprintf(stderr, "error=%d\n", err->error); 1653 msg = "unknown parsing error"; 1654 break; 1655 } 1656 v = Py_BuildValue("(ziiz)", err->filename, 1657 err->lineno, err->offset, err->text); 1658 w = NULL; 1659 if (v != NULL) 1660 w = Py_BuildValue("(sO)", msg, v); 1661 Py_XDECREF(u); 1662 Py_XDECREF(v); 1663 PyErr_SetObject(errtype, w); 1664 Py_XDECREF(w); 1665 cleanup: 1666 if (err->text != NULL) { 1667 PyObject_FREE(err->text); 1668 err->text = NULL; 1669 } 1670 } 1671 1672 /* Print fatal error message and abort */ 1673 1674 void 1675 Py_FatalError(const char *msg) 1676 { 1677 fprintf(stderr, "Fatal Python error: %s\n", msg); 1678 fflush(stderr); /* it helps in Windows debug build */ 1679 1680 #ifdef MS_WINDOWS 1681 { 1682 size_t len = strlen(msg); 1683 WCHAR* buffer; 1684 size_t i; 1685 1686 /* Convert the message to wchar_t. This uses a simple one-to-one 1687 conversion, assuming that the this error message actually uses ASCII 1688 only. If this ceases to be true, we will have to convert. */ 1689 buffer = alloca( (len+1) * (sizeof *buffer)); 1690 for( i=0; i<=len; ++i) 1691 buffer[i] = msg[i]; 1692 OutputDebugStringW(L"Fatal Python error: "); 1693 OutputDebugStringW(buffer); 1694 OutputDebugStringW(L"\n"); 1695 } 1696 #ifdef _DEBUG 1697 DebugBreak(); 1698 #endif 1699 #endif /* MS_WINDOWS */ 1700 abort(); 1701 } 1702 1703 /* Clean up and exit */ 1704 1705 #ifdef WITH_THREAD 1706 #include "pythread.h" 1707 #endif 1708 1709 /* Wait until threading._shutdown completes, provided 1710 the threading module was imported in the first place. 1711 The shutdown routine will wait until all non-daemon 1712 "threading" threads have completed. */ 1713 static void 1714 wait_for_thread_shutdown(void) 1715 { 1716 #ifdef WITH_THREAD 1717 PyObject *result; 1718 PyThreadState *tstate = PyThreadState_GET(); 1719 PyObject *threading = PyMapping_GetItemString(tstate->interp->modules, 1720 "threading"); 1721 if (threading == NULL) { 1722 /* threading not imported */ 1723 PyErr_Clear(); 1724 return; 1725 } 1726 result = PyObject_CallMethod(threading, "_shutdown", ""); 1727 if (result == NULL) 1728 PyErr_WriteUnraisable(threading); 1729 else 1730 Py_DECREF(result); 1731 Py_DECREF(threading); 1732 #endif 1733 } 1734 1735 #define NEXITFUNCS 32 1736 static void (*exitfuncs[NEXITFUNCS])(void); 1737 static int nexitfuncs = 0; 1738 1739 int Py_AtExit(void (*func)(void)) 1740 { 1741 if (nexitfuncs >= NEXITFUNCS) 1742 return -1; 1743 exitfuncs[nexitfuncs++] = func; 1744 return 0; 1745 } 1746 1747 static void 1748 call_sys_exitfunc(void) 1749 { 1750 PyObject *exitfunc = PySys_GetObject("exitfunc"); 1751 1752 if (exitfunc) { 1753 PyObject *res; 1754 Py_INCREF(exitfunc); 1755 PySys_SetObject("exitfunc", (PyObject *)NULL); 1756 res = PyEval_CallObject(exitfunc, (PyObject *)NULL); 1757 if (res == NULL) { 1758 if (!PyErr_ExceptionMatches(PyExc_SystemExit)) { 1759 PySys_WriteStderr("Error in sys.exitfunc:\n"); 1760 } 1761 PyErr_Print(); 1762 } 1763 Py_DECREF(exitfunc); 1764 } 1765 1766 if (Py_FlushLine()) 1767 PyErr_Clear(); 1768 } 1769 1770 static void 1771 call_ll_exitfuncs(void) 1772 { 1773 while (nexitfuncs > 0) 1774 (*exitfuncs[--nexitfuncs])(); 1775 1776 fflush(stdout); 1777 fflush(stderr); 1778 } 1779 1780 void 1781 Py_Exit(int sts) 1782 { 1783 Py_Finalize(); 1784 1785 exit(sts); 1786 } 1787 1788 static void 1789 initsigs(void) 1790 { 1791 #ifdef SIGPIPE 1792 PyOS_setsig(SIGPIPE, SIG_IGN); 1793 #endif 1794 #ifdef SIGXFZ 1795 PyOS_setsig(SIGXFZ, SIG_IGN); 1796 #endif 1797 #ifdef SIGXFSZ 1798 PyOS_setsig(SIGXFSZ, SIG_IGN); 1799 #endif 1800 PyOS_InitInterrupts(); /* May imply initsignal() */ 1801 } 1802 1803 1804 /* 1805 * The file descriptor fd is considered ``interactive'' if either 1806 * a) isatty(fd) is TRUE, or 1807 * b) the -i flag was given, and the filename associated with 1808 * the descriptor is NULL or "<stdin>" or "???". 1809 */ 1810 int 1811 Py_FdIsInteractive(FILE *fp, const char *filename) 1812 { 1813 if (isatty((int)fileno(fp))) 1814 return 1; 1815 if (!Py_InteractiveFlag) 1816 return 0; 1817 return (filename == NULL) || 1818 (strcmp(filename, "<stdin>") == 0) || 1819 (strcmp(filename, "???") == 0); 1820 } 1821 1822 1823 #if defined(USE_STACKCHECK) 1824 #if defined(WIN32) && defined(_MSC_VER) 1825 1826 /* Stack checking for Microsoft C */ 1827 1828 #include <malloc.h> 1829 #include <excpt.h> 1830 1831 /* 1832 * Return non-zero when we run out of memory on the stack; zero otherwise. 1833 */ 1834 int 1835 PyOS_CheckStack(void) 1836 { 1837 __try { 1838 /* alloca throws a stack overflow exception if there's 1839 not enough space left on the stack */ 1840 alloca(PYOS_STACK_MARGIN * sizeof(void*)); 1841 return 0; 1842 } __except (GetExceptionCode() == STATUS_STACK_OVERFLOW ? 1843 EXCEPTION_EXECUTE_HANDLER : 1844 EXCEPTION_CONTINUE_SEARCH) { 1845 int errcode = _resetstkoflw(); 1846 if (errcode == 0) 1847 { 1848 Py_FatalError("Could not reset the stack!"); 1849 } 1850 } 1851 return 1; 1852 } 1853 1854 #endif /* WIN32 && _MSC_VER */ 1855 1856 /* Alternate implementations can be added here... */ 1857 1858 #endif /* USE_STACKCHECK */ 1859 1860 1861 /* Wrappers around sigaction() or signal(). */ 1862 1863 PyOS_sighandler_t 1864 PyOS_getsig(int sig) 1865 { 1866 #ifdef HAVE_SIGACTION 1867 struct sigaction context; 1868 if (sigaction(sig, NULL, &context) == -1) 1869 return SIG_ERR; 1870 return context.sa_handler; 1871 #else 1872 PyOS_sighandler_t handler; 1873 /* Special signal handling for the secure CRT in Visual Studio 2005 */ 1874 #if defined(_MSC_VER) && _MSC_VER >= 1400 1875 switch (sig) { 1876 /* Only these signals are valid */ 1877 case SIGINT: 1878 case SIGILL: 1879 case SIGFPE: 1880 case SIGSEGV: 1881 case SIGTERM: 1882 case SIGBREAK: 1883 case SIGABRT: 1884 break; 1885 /* Don't call signal() with other values or it will assert */ 1886 default: 1887 return SIG_ERR; 1888 } 1889 #endif /* _MSC_VER && _MSC_VER >= 1400 */ 1890 handler = signal(sig, SIG_IGN); 1891 if (handler != SIG_ERR) 1892 signal(sig, handler); 1893 return handler; 1894 #endif 1895 } 1896 1897 PyOS_sighandler_t 1898 PyOS_setsig(int sig, PyOS_sighandler_t handler) 1899 { 1900 #ifdef HAVE_SIGACTION 1901 /* Some code in Modules/signalmodule.c depends on sigaction() being 1902 * used here if HAVE_SIGACTION is defined. Fix that if this code 1903 * changes to invalidate that assumption. 1904 */ 1905 struct sigaction context, ocontext; 1906 context.sa_handler = handler; 1907 sigemptyset(&context.sa_mask); 1908 context.sa_flags = 0; 1909 if (sigaction(sig, &context, &ocontext) == -1) 1910 return SIG_ERR; 1911 return ocontext.sa_handler; 1912 #else 1913 PyOS_sighandler_t oldhandler; 1914 oldhandler = signal(sig, handler); 1915 #ifdef HAVE_SIGINTERRUPT 1916 siginterrupt(sig, 1); 1917 #endif 1918 return oldhandler; 1919 #endif 1920 } 1921 1922 /* Deprecated C API functions still provided for binary compatibility */ 1923 1924 #undef PyParser_SimpleParseFile 1925 PyAPI_FUNC(node *) 1926 PyParser_SimpleParseFile(FILE *fp, const char *filename, int start) 1927 { 1928 return PyParser_SimpleParseFileFlags(fp, filename, start, 0); 1929 } 1930 1931 #undef PyParser_SimpleParseString 1932 PyAPI_FUNC(node *) 1933 PyParser_SimpleParseString(const char *str, int start) 1934 { 1935 return PyParser_SimpleParseStringFlags(str, start, 0); 1936 } 1937 1938 #undef PyRun_AnyFile 1939 PyAPI_FUNC(int) 1940 PyRun_AnyFile(FILE *fp, const char *name) 1941 { 1942 return PyRun_AnyFileExFlags(fp, name, 0, NULL); 1943 } 1944 1945 #undef PyRun_AnyFileEx 1946 PyAPI_FUNC(int) 1947 PyRun_AnyFileEx(FILE *fp, const char *name, int closeit) 1948 { 1949 return PyRun_AnyFileExFlags(fp, name, closeit, NULL); 1950 } 1951 1952 #undef PyRun_AnyFileFlags 1953 PyAPI_FUNC(int) 1954 PyRun_AnyFileFlags(FILE *fp, const char *name, PyCompilerFlags *flags) 1955 { 1956 return PyRun_AnyFileExFlags(fp, name, 0, flags); 1957 } 1958 1959 #undef PyRun_File 1960 PyAPI_FUNC(PyObject *) 1961 PyRun_File(FILE *fp, const char *p, int s, PyObject *g, PyObject *l) 1962 { 1963 return PyRun_FileExFlags(fp, p, s, g, l, 0, NULL); 1964 } 1965 1966 #undef PyRun_FileEx 1967 PyAPI_FUNC(PyObject *) 1968 PyRun_FileEx(FILE *fp, const char *p, int s, PyObject *g, PyObject *l, int c) 1969 { 1970 return PyRun_FileExFlags(fp, p, s, g, l, c, NULL); 1971 } 1972 1973 #undef PyRun_FileFlags 1974 PyAPI_FUNC(PyObject *) 1975 PyRun_FileFlags(FILE *fp, const char *p, int s, PyObject *g, PyObject *l, 1976 PyCompilerFlags *flags) 1977 { 1978 return PyRun_FileExFlags(fp, p, s, g, l, 0, flags); 1979 } 1980 1981 #undef PyRun_SimpleFile 1982 PyAPI_FUNC(int) 1983 PyRun_SimpleFile(FILE *f, const char *p) 1984 { 1985 return PyRun_SimpleFileExFlags(f, p, 0, NULL); 1986 } 1987 1988 #undef PyRun_SimpleFileEx 1989 PyAPI_FUNC(int) 1990 PyRun_SimpleFileEx(FILE *f, const char *p, int c) 1991 { 1992 return PyRun_SimpleFileExFlags(f, p, c, NULL); 1993 } 1994 1995 1996 #undef PyRun_String 1997 PyAPI_FUNC(PyObject *) 1998 PyRun_String(const char *str, int s, PyObject *g, PyObject *l) 1999 { 2000 return PyRun_StringFlags(str, s, g, l, NULL); 2001 } 2002 2003 #undef PyRun_SimpleString 2004 PyAPI_FUNC(int) 2005 PyRun_SimpleString(const char *s) 2006 { 2007 return PyRun_SimpleStringFlags(s, NULL); 2008 } 2009 2010 #undef Py_CompileString 2011 PyAPI_FUNC(PyObject *) 2012 Py_CompileString(const char *str, const char *p, int s) 2013 { 2014 return Py_CompileStringFlags(str, p, s, NULL); 2015 } 2016 2017 #undef PyRun_InteractiveOne 2018 PyAPI_FUNC(int) 2019 PyRun_InteractiveOne(FILE *f, const char *p) 2020 { 2021 return PyRun_InteractiveOneFlags(f, p, NULL); 2022 } 2023 2024 #undef PyRun_InteractiveLoop 2025 PyAPI_FUNC(int) 2026 PyRun_InteractiveLoop(FILE *f, const char *p) 2027 { 2028 return PyRun_InteractiveLoopFlags(f, p, NULL); 2029 } 2030 2031 #ifdef __cplusplus 2032 } 2033 #endif 2034 2035
