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