2 /* Python interpreter top-level routines, including init/exit */
6 #include "Python-ast.h"
24 #ifdef HAVE_LANGINFO_H
35 #define PRINT_TOTAL_REFS()
36 #else /* Py_REF_DEBUG */
37 #define PRINT_TOTAL_REFS() fprintf(stderr, \
38 "[%" PY_FORMAT_SIZE_T "d refs]\n", \
46 extern char *Py_GetPath(void);
48 extern grammar _PyParser_Grammar
; /* From graminit.c */
51 static void initmain(void);
52 static void initsite(void);
53 static PyObject
*run_mod(mod_ty
, const char *, PyObject
*, PyObject
*,
54 PyCompilerFlags
*, PyArena
*);
55 static PyObject
*run_pyc_file(FILE *, const char *, PyObject
*, PyObject
*,
57 static void err_input(perrdetail
*);
58 static void initsigs(void);
59 static void call_sys_exitfunc(void);
60 static void call_ll_exitfuncs(void);
61 extern void _PyUnicode_Init(void);
62 extern void _PyUnicode_Fini(void);
65 extern void _PyGILState_Init(PyInterpreterState
*, PyThreadState
*);
66 extern void _PyGILState_Fini(void);
67 #endif /* WITH_THREAD */
69 int Py_DebugFlag
; /* Needed by parser.c */
70 int Py_VerboseFlag
; /* Needed by import.c */
71 int Py_InteractiveFlag
; /* Needed by Py_FdIsInteractive() below */
72 int Py_NoSiteFlag
; /* Suppress 'import site' */
73 int Py_UseClassExceptionsFlag
= 1; /* Needed by bltinmodule.c: deprecated */
74 int Py_FrozenFlag
; /* Needed by getpath.c */
75 int Py_UnicodeFlag
= 0; /* Needed by compile.c */
76 int Py_IgnoreEnvironmentFlag
; /* e.g. PYTHONPATH, PYTHONHOME */
77 /* _XXX Py_QnewFlag should go away in 2.3. It's true iff -Qnew is passed,
78 on the command line, and is used in 2.2 by ceval.c to make all "/" divisions
79 true divisions (which they will be in 2.3). */
82 /* Reference to 'warnings' module, to avoid importing it
83 on the fly when the import lock may be held. See 683658/771097
85 static PyObject
*warnings_module
= NULL
;
87 /* Returns a borrowed reference to the 'warnings' module, or NULL.
88 If the module is returned, it is guaranteed to have been obtained
89 without acquiring the import lock
91 PyObject
*PyModule_GetWarningsModule(void)
93 PyObject
*typ
, *val
, *tb
;
94 PyObject
*all_modules
;
95 /* If we managed to get the module at init time, just use it */
97 return warnings_module
;
98 /* If it wasn't available at init time, it may be available
99 now in sys.modules (common scenario is frozen apps: import
100 at init time fails, but the frozen init code sets up sys.path
101 correctly, then does an implicit import of warnings for us
103 /* Save and restore any exceptions */
104 PyErr_Fetch(&typ
, &val
, &tb
);
106 all_modules
= PySys_GetObject("modules");
108 warnings_module
= PyDict_GetItemString(all_modules
, "warnings");
109 /* We keep a ref in the global */
110 Py_XINCREF(warnings_module
);
112 PyErr_Restore(typ
, val
, tb
);
113 return warnings_module
;
116 static int initialized
= 0;
118 /* API to access the initialized flag -- useful for esoteric use */
121 Py_IsInitialized(void)
126 /* Global initializations. Can be undone by Py_Finalize(). Don't
127 call this twice without an intervening Py_Finalize() call. When
128 initializations fail, a fatal error is issued and the function does
129 not return. On return, the first thread and interpreter state have
132 Locking: you must hold the interpreter lock while calling this.
133 (If the lock has not yet been initialized, that's equivalent to
134 having the lock, but you cannot use multiple threads.)
139 add_flag(int flag
, const char *envs
)
141 int env
= atoi(envs
);
150 Py_InitializeEx(int install_sigs
)
152 PyInterpreterState
*interp
;
153 PyThreadState
*tstate
;
154 PyObject
*bimod
, *sysmod
;
156 #if defined(Py_USING_UNICODE) && defined(HAVE_LANGINFO_H) && defined(CODESET)
159 PyObject
*sys_stream
, *sys_isatty
;
161 extern void _Py_ReadyTypes(void);
167 if ((p
= Py_GETENV("PYTHONDEBUG")) && *p
!= '\0')
168 Py_DebugFlag
= add_flag(Py_DebugFlag
, p
);
169 if ((p
= Py_GETENV("PYTHONVERBOSE")) && *p
!= '\0')
170 Py_VerboseFlag
= add_flag(Py_VerboseFlag
, p
);
171 if ((p
= Py_GETENV("PYTHONOPTIMIZE")) && *p
!= '\0')
172 Py_OptimizeFlag
= add_flag(Py_OptimizeFlag
, p
);
174 interp
= PyInterpreterState_New();
176 Py_FatalError("Py_Initialize: can't make first interpreter");
178 tstate
= PyThreadState_New(interp
);
180 Py_FatalError("Py_Initialize: can't make first thread");
181 (void) PyThreadState_Swap(tstate
);
185 if (!_PyFrame_Init())
186 Py_FatalError("Py_Initialize: can't init frames");
189 Py_FatalError("Py_Initialize: can't init ints");
193 interp
->modules
= PyDict_New();
194 if (interp
->modules
== NULL
)
195 Py_FatalError("Py_Initialize: can't make modules dictionary");
197 #ifdef Py_USING_UNICODE
198 /* Init Unicode implementation; relies on the codec registry */
202 bimod
= _PyBuiltin_Init();
204 Py_FatalError("Py_Initialize: can't initialize __builtin__");
205 interp
->builtins
= PyModule_GetDict(bimod
);
206 Py_INCREF(interp
->builtins
);
208 sysmod
= _PySys_Init();
210 Py_FatalError("Py_Initialize: can't initialize sys");
211 interp
->sysdict
= PyModule_GetDict(sysmod
);
212 Py_INCREF(interp
->sysdict
);
213 _PyImport_FixupExtension("sys", "sys");
214 PySys_SetPath(Py_GetPath());
215 PyDict_SetItemString(interp
->sysdict
, "modules",
220 /* initialize builtin exceptions */
222 _PyImport_FixupExtension("exceptions", "exceptions");
224 /* phase 2 of builtins */
225 _PyImport_FixupExtension("__builtin__", "__builtin__");
227 _PyImportHooks_Init();
230 initsigs(); /* Signal handling stuff, including initintr() */
232 initmain(); /* Module __main__ */
234 initsite(); /* Module site */
236 /* auto-thread-state API, if available */
238 _PyGILState_Init(interp
, tstate
);
239 #endif /* WITH_THREAD */
241 warnings_module
= PyImport_ImportModule("warnings");
242 if (!warnings_module
)
245 #if defined(Py_USING_UNICODE) && defined(HAVE_LANGINFO_H) && defined(CODESET)
246 /* On Unix, set the file system encoding according to the
247 user's preference, if the CODESET names a well-known
248 Python codec, and Py_FileSystemDefaultEncoding isn't
249 initialized by other means. Also set the encoding of
250 stdin and stdout if these are terminals. */
252 saved_locale
= strdup(setlocale(LC_CTYPE
, NULL
));
253 setlocale(LC_CTYPE
, "");
254 codeset
= nl_langinfo(CODESET
);
255 if (codeset
&& *codeset
) {
256 PyObject
*enc
= PyCodec_Encoder(codeset
);
258 codeset
= strdup(codeset
);
266 setlocale(LC_CTYPE
, saved_locale
);
270 sys_stream
= PySys_GetObject("stdin");
271 sys_isatty
= PyObject_CallMethod(sys_stream
, "isatty", "");
274 if(sys_isatty
&& PyObject_IsTrue(sys_isatty
)) {
275 if (!PyFile_SetEncoding(sys_stream
, codeset
))
276 Py_FatalError("Cannot set codeset of stdin");
278 Py_XDECREF(sys_isatty
);
280 sys_stream
= PySys_GetObject("stdout");
281 sys_isatty
= PyObject_CallMethod(sys_stream
, "isatty", "");
284 if(sys_isatty
&& PyObject_IsTrue(sys_isatty
)) {
285 if (!PyFile_SetEncoding(sys_stream
, codeset
))
286 Py_FatalError("Cannot set codeset of stdout");
288 Py_XDECREF(sys_isatty
);
290 sys_stream
= PySys_GetObject("stderr");
291 sys_isatty
= PyObject_CallMethod(sys_stream
, "isatty", "");
294 if(sys_isatty
&& PyObject_IsTrue(sys_isatty
)) {
295 if (!PyFile_SetEncoding(sys_stream
, codeset
))
296 Py_FatalError("Cannot set codeset of stderr");
298 Py_XDECREF(sys_isatty
);
300 if (!Py_FileSystemDefaultEncoding
)
301 Py_FileSystemDefaultEncoding
= codeset
;
316 extern void dump_counts(FILE*);
319 /* Undo the effect of Py_Initialize().
321 Beware: if multiple interpreter and/or thread states exist, these
322 are not wiped out; only the current thread and interpreter state
323 are deleted. But since everything else is deleted, those other
324 interpreter and thread states should no longer be used.
326 (XXX We should do better, e.g. wipe out all interpreters and
336 PyInterpreterState
*interp
;
337 PyThreadState
*tstate
;
342 /* The interpreter is still entirely intact at this point, and the
343 * exit funcs may be relying on that. In particular, if some thread
344 * or exit func is still waiting to do an import, the import machinery
345 * expects Py_IsInitialized() to return true. So don't say the
346 * interpreter is uninitialized until after the exit funcs have run.
347 * Note that Threading.py uses an exit func to do a join on all the
348 * threads created thru it, so this also protects pending imports in
349 * the threads created via Threading.
354 /* Get current thread state and interpreter pointer */
355 tstate
= PyThreadState_GET();
356 interp
= tstate
->interp
;
358 /* Disable signal handling */
359 PyOS_FiniInterrupts();
361 /* drop module references we saved */
362 Py_XDECREF(warnings_module
);
363 warnings_module
= NULL
;
365 /* Collect garbage. This may call finalizers; it's nice to call these
366 * before all modules are destroyed.
367 * XXX If a __del__ or weakref callback is triggered here, and tries to
368 * XXX import a module, bad things can happen, because Python no
369 * XXX longer believes it's initialized.
370 * XXX Fatal Python error: Interpreter not initialized (version mismatch?)
371 * XXX is easy to provoke that way. I've also seen, e.g.,
372 * XXX Exception exceptions.ImportError: 'No module named sha'
373 * XXX in <function callback at 0x008F5718> ignored
374 * XXX but I'm unclear on exactly how that one happens. In any case,
375 * XXX I haven't seen a real-life report of either of these.
379 /* With COUNT_ALLOCS, it helps to run GC multiple times:
380 each collection might release some types from the type
381 list, so they become garbage. */
382 while (PyGC_Collect() > 0)
386 /* Destroy all modules */
389 /* Collect final garbage. This disposes of cycles created by
390 * new-style class definitions, for example.
391 * XXX This is disabled because it caused too many problems. If
392 * XXX a __del__ or weakref callback triggers here, Python code has
393 * XXX a hard time running, because even the sys module has been
394 * XXX cleared out (sys.stdout is gone, sys.excepthook is gone, etc).
395 * XXX One symptom is a sequence of information-free messages
396 * XXX coming from threads (if a __del__ or callback is invoked,
397 * XXX other threads can execute too, and any exception they encounter
398 * XXX triggers a comedy of errors as subsystem after subsystem
399 * XXX fails to find what it *expects* to find in sys to help report
400 * XXX the exception and consequent unexpected failures). I've also
401 * XXX seen segfaults then, after adding print statements to the
402 * XXX Python code getting called.
408 /* Destroy the database used by _PyImport_{Fixup,Find}Extension */
411 /* Debugging stuff */
419 /* Display all objects still alive -- this can invoke arbitrary
420 * __repr__ overrides, so requires a mostly-intact interpreter.
421 * Alas, a lot of stuff may still be alive now that will be cleaned
424 if (Py_GETENV("PYTHONDUMPREFS"))
425 _Py_PrintReferences(stderr
);
426 #endif /* Py_TRACE_REFS */
428 /* Cleanup auto-thread-state */
431 #endif /* WITH_THREAD */
433 /* Clear interpreter state */
434 PyInterpreterState_Clear(interp
);
436 /* Now we decref the exception classes. After this point nothing
437 can raise an exception. That's okay, because each Fini() method
438 below has been checked to make sure no exceptions are ever
444 /* Delete current thread */
445 PyThreadState_Swap(NULL
);
446 PyInterpreterState_Delete(interp
);
448 /* Sundry finalizers */
459 #ifdef Py_USING_UNICODE
460 /* Cleanup Unicode implementation */
464 /* XXX Still allocated:
465 - various static ad-hoc pointers to interned strings
466 - int and float free list blocks
467 - whatever various modules and libraries allocate
470 PyGrammar_RemoveAccelerators(&_PyParser_Grammar
);
473 /* Display addresses (& refcnts) of all objects still alive.
474 * An address can be used to find the repr of the object, printed
475 * above by _Py_PrintReferences.
477 if (Py_GETENV("PYTHONDUMPREFS"))
478 _Py_PrintReferenceAddresses(stderr
);
479 #endif /* Py_TRACE_REFS */
480 #ifdef PYMALLOC_DEBUG
481 if (Py_GETENV("PYTHONMALLOCSTATS"))
482 _PyObject_DebugMallocStats();
488 /* Create and initialize a new interpreter and thread, and return the
489 new thread. This requires that Py_Initialize() has been called
492 Unsuccessful initialization yields a NULL pointer. Note that *no*
493 exception information is available even in this case -- the
494 exception information is held in the thread, and there is no
502 Py_NewInterpreter(void)
504 PyInterpreterState
*interp
;
505 PyThreadState
*tstate
, *save_tstate
;
506 PyObject
*bimod
, *sysmod
;
509 Py_FatalError("Py_NewInterpreter: call Py_Initialize first");
511 interp
= PyInterpreterState_New();
515 tstate
= PyThreadState_New(interp
);
516 if (tstate
== NULL
) {
517 PyInterpreterState_Delete(interp
);
521 save_tstate
= PyThreadState_Swap(tstate
);
523 /* XXX The following is lax in error checking */
525 interp
->modules
= PyDict_New();
527 bimod
= _PyImport_FindExtension("__builtin__", "__builtin__");
529 interp
->builtins
= PyModule_GetDict(bimod
);
530 Py_INCREF(interp
->builtins
);
532 sysmod
= _PyImport_FindExtension("sys", "sys");
533 if (bimod
!= NULL
&& sysmod
!= NULL
) {
534 interp
->sysdict
= PyModule_GetDict(sysmod
);
535 Py_INCREF(interp
->sysdict
);
536 PySys_SetPath(Py_GetPath());
537 PyDict_SetItemString(interp
->sysdict
, "modules",
539 _PyImportHooks_Init();
545 if (!PyErr_Occurred())
548 /* Oops, it didn't work. Undo it all. */
551 PyThreadState_Clear(tstate
);
552 PyThreadState_Swap(save_tstate
);
553 PyThreadState_Delete(tstate
);
554 PyInterpreterState_Delete(interp
);
559 /* Delete an interpreter and its last thread. This requires that the
560 given thread state is current, that the thread has no remaining
561 frames, and that it is its interpreter's only remaining thread.
562 It is a fatal error to violate these constraints.
564 (Py_Finalize() doesn't have these constraints -- it zaps
565 everything, regardless.)
572 Py_EndInterpreter(PyThreadState
*tstate
)
574 PyInterpreterState
*interp
= tstate
->interp
;
576 if (tstate
!= PyThreadState_GET())
577 Py_FatalError("Py_EndInterpreter: thread is not current");
578 if (tstate
->frame
!= NULL
)
579 Py_FatalError("Py_EndInterpreter: thread still has a frame");
580 if (tstate
!= interp
->tstate_head
|| tstate
->next
!= NULL
)
581 Py_FatalError("Py_EndInterpreter: not the last thread");
584 PyInterpreterState_Clear(interp
);
585 PyThreadState_Swap(NULL
);
586 PyInterpreterState_Delete(interp
);
589 static char *progname
= "python";
592 Py_SetProgramName(char *pn
)
599 Py_GetProgramName(void)
604 static char *default_home
= NULL
;
607 Py_SetPythonHome(char *home
)
613 Py_GetPythonHome(void)
615 char *home
= default_home
;
616 if (home
== NULL
&& !Py_IgnoreEnvironmentFlag
)
617 home
= Py_GETENV("PYTHONHOME");
621 /* Create __main__ module */
627 m
= PyImport_AddModule("__main__");
629 Py_FatalError("can't create __main__ module");
630 d
= PyModule_GetDict(m
);
631 if (PyDict_GetItemString(d
, "__builtins__") == NULL
) {
632 PyObject
*bimod
= PyImport_ImportModule("__builtin__");
634 PyDict_SetItemString(d
, "__builtins__", bimod
) != 0)
635 Py_FatalError("can't add __builtins__ to __main__");
640 /* Import the site module (not into __main__ though) */
646 m
= PyImport_ImportModule("site");
648 f
= PySys_GetObject("stderr");
649 if (Py_VerboseFlag
) {
651 "'import site' failed; traceback:\n", f
);
656 "'import site' failed; use -v for traceback\n", f
);
665 /* Parse input from a file and execute it */
668 PyRun_AnyFileExFlags(FILE *fp
, const char *filename
, int closeit
,
669 PyCompilerFlags
*flags
)
671 if (filename
== NULL
)
673 if (Py_FdIsInteractive(fp
, filename
)) {
674 int err
= PyRun_InteractiveLoopFlags(fp
, filename
, flags
);
680 return PyRun_SimpleFileExFlags(fp
, filename
, closeit
, flags
);
684 PyRun_InteractiveLoopFlags(FILE *fp
, const char *filename
, PyCompilerFlags
*flags
)
688 PyCompilerFlags local_flags
;
691 flags
= &local_flags
;
692 local_flags
.cf_flags
= 0;
694 v
= PySys_GetObject("ps1");
696 PySys_SetObject("ps1", v
= PyString_FromString(">>> "));
699 v
= PySys_GetObject("ps2");
701 PySys_SetObject("ps2", v
= PyString_FromString("... "));
705 ret
= PyRun_InteractiveOneFlags(fp
, filename
, flags
);
716 /* compute parser flags based on compiler flags */
717 #define PARSER_FLAGS(flags) \
718 ((flags) ? ((((flags)->cf_flags & PyCF_DONT_IMPLY_DEDENT) ? \
719 PyPARSE_DONT_IMPLY_DEDENT : 0) \
720 | ((flags)->cf_flags & CO_FUTURE_WITH_STATEMENT ? \
721 PyPARSE_WITH_IS_KEYWORD : 0)) : 0)
724 PyRun_InteractiveOneFlags(FILE *fp
, const char *filename
, PyCompilerFlags
*flags
)
726 PyObject
*m
, *d
, *v
, *w
;
729 char *ps1
= "", *ps2
= "";
732 v
= PySys_GetObject("ps1");
737 else if (PyString_Check(v
))
738 ps1
= PyString_AsString(v
);
740 w
= PySys_GetObject("ps2");
745 else if (PyString_Check(w
))
746 ps2
= PyString_AsString(w
);
748 arena
= PyArena_New();
749 mod
= PyParser_ASTFromFile(fp
, filename
,
750 Py_single_input
, ps1
, ps2
,
751 flags
, &errcode
, arena
);
756 if (errcode
== E_EOF
) {
763 m
= PyImport_AddModule("__main__");
768 d
= PyModule_GetDict(m
);
769 v
= run_mod(mod
, filename
, d
, d
, flags
, arena
);
781 /* Check whether a file maybe a pyc file: Look at the extension,
782 the file type, and, if we may close it, at the first few bytes. */
785 maybe_pyc_file(FILE *fp
, const char* filename
, const char* ext
, int closeit
)
787 if (strcmp(ext
, ".pyc") == 0 || strcmp(ext
, ".pyo") == 0)
790 /* Only look into the file if we are allowed to close it, since
791 it then should also be seekable. */
793 /* Read only two bytes of the magic. If the file was opened in
794 text mode, the bytes 3 and 4 of the magic (\r\n) might not
795 be read as they are on disk. */
796 unsigned int halfmagic
= PyImport_GetMagicNumber() & 0xFFFF;
797 unsigned char buf
[2];
798 /* Mess: In case of -x, the stream is NOT at its start now,
799 and ungetc() was used to push back the first newline,
800 which makes the current stream position formally undefined,
801 and a x-platform nightmare.
802 Unfortunately, we have no direct way to know whether -x
803 was specified. So we use a terrible hack: if the current
804 stream position is not 0, we assume -x was specified, and
805 give up. Bug 132850 on SourceForge spells out the
806 hopelessness of trying anything else (fseek and ftell
807 don't work predictably x-platform for text-mode files).
810 if (ftell(fp
) == 0) {
811 if (fread(buf
, 1, 2, fp
) == 2 &&
812 ((unsigned int)buf
[1]<<8 | buf
[0]) == halfmagic
)
822 PyRun_SimpleFileExFlags(FILE *fp
, const char *filename
, int closeit
,
823 PyCompilerFlags
*flags
)
828 m
= PyImport_AddModule("__main__");
831 d
= PyModule_GetDict(m
);
832 if (PyDict_GetItemString(d
, "__file__") == NULL
) {
833 PyObject
*f
= PyString_FromString(filename
);
836 if (PyDict_SetItemString(d
, "__file__", f
) < 0) {
842 ext
= filename
+ strlen(filename
) - 4;
843 if (maybe_pyc_file(fp
, filename
, ext
, closeit
)) {
844 /* Try to run a pyc file. First, re-open in binary */
847 if ((fp
= fopen(filename
, "rb")) == NULL
) {
848 fprintf(stderr
, "python: Can't reopen .pyc file\n");
851 /* Turn on optimization if a .pyo file is given */
852 if (strcmp(ext
, ".pyo") == 0)
854 v
= run_pyc_file(fp
, filename
, d
, d
, flags
);
856 v
= PyRun_FileExFlags(fp
, filename
, Py_file_input
, d
, d
,
870 PyRun_SimpleStringFlags(const char *command
, PyCompilerFlags
*flags
)
873 m
= PyImport_AddModule("__main__");
876 d
= PyModule_GetDict(m
);
877 v
= PyRun_StringFlags(command
, Py_file_input
, d
, d
, flags
);
889 parse_syntax_error(PyObject
*err
, PyObject
**message
, const char **filename
,
890 int *lineno
, int *offset
, const char **text
)
895 /* old style errors */
896 if (PyTuple_Check(err
))
897 return PyArg_ParseTuple(err
, "O(ziiz)", message
, filename
,
898 lineno
, offset
, text
);
900 /* new style errors. `err' is an instance */
902 if (! (v
= PyObject_GetAttrString(err
, "msg")))
906 if (!(v
= PyObject_GetAttrString(err
, "filename")))
910 else if (! (*filename
= PyString_AsString(v
)))
914 if (!(v
= PyObject_GetAttrString(err
, "lineno")))
916 hold
= PyInt_AsLong(v
);
919 if (hold
< 0 && PyErr_Occurred())
923 if (!(v
= PyObject_GetAttrString(err
, "offset")))
930 hold
= PyInt_AsLong(v
);
933 if (hold
< 0 && PyErr_Occurred())
938 if (!(v
= PyObject_GetAttrString(err
, "text")))
942 else if (! (*text
= PyString_AsString(v
)))
959 print_error_text(PyObject
*f
, int offset
, const char *text
)
963 if (offset
> 0 && offset
== (int)strlen(text
))
966 nl
= strchr(text
, '\n');
967 if (nl
== NULL
|| nl
-text
>= offset
)
969 offset
-= (int)(nl
+1-text
);
972 while (*text
== ' ' || *text
== '\t') {
977 PyFile_WriteString(" ", f
);
978 PyFile_WriteString(text
, f
);
979 if (*text
== '\0' || text
[strlen(text
)-1] != '\n')
980 PyFile_WriteString("\n", f
);
983 PyFile_WriteString(" ", f
);
986 PyFile_WriteString(" ", f
);
989 PyFile_WriteString("^\n", f
);
993 handle_system_exit(void)
995 PyObject
*exception
, *value
, *tb
;
998 PyErr_Fetch(&exception
, &value
, &tb
);
1002 if (value
== NULL
|| value
== Py_None
)
1004 if (PyExceptionInstance_Check(value
)) {
1005 /* The error code should be in the `code' attribute. */
1006 PyObject
*code
= PyObject_GetAttrString(value
, "code");
1010 if (value
== Py_None
)
1013 /* If we failed to dig out the 'code' attribute,
1014 just let the else clause below print the error. */
1016 if (PyInt_Check(value
))
1017 exitcode
= (int)PyInt_AsLong(value
);
1019 PyObject_Print(value
, stderr
, Py_PRINT_RAW
);
1020 PySys_WriteStderr("\n");
1024 /* Restore and clear the exception info, in order to properly decref
1025 * the exception, value, and traceback. If we just exit instead,
1026 * these leak, which confuses PYTHONDUMPREFS output, and may prevent
1027 * some finalizers from running.
1029 PyErr_Restore(exception
, value
, tb
);
1036 PyErr_PrintEx(int set_sys_last_vars
)
1038 PyObject
*exception
, *v
, *tb
, *hook
;
1040 if (PyErr_ExceptionMatches(PyExc_SystemExit
)) {
1041 handle_system_exit();
1043 PyErr_Fetch(&exception
, &v
, &tb
);
1044 if (exception
== NULL
)
1046 PyErr_NormalizeException(&exception
, &v
, &tb
);
1047 if (exception
== NULL
)
1049 /* Now we know v != NULL too */
1050 if (set_sys_last_vars
) {
1051 PySys_SetObject("last_type", exception
);
1052 PySys_SetObject("last_value", v
);
1053 PySys_SetObject("last_traceback", tb
);
1055 hook
= PySys_GetObject("excepthook");
1057 PyObject
*args
= PyTuple_Pack(3,
1058 exception
, v
, tb
? tb
: Py_None
);
1059 PyObject
*result
= PyEval_CallObject(hook
, args
);
1060 if (result
== NULL
) {
1061 PyObject
*exception2
, *v2
, *tb2
;
1062 if (PyErr_ExceptionMatches(PyExc_SystemExit
)) {
1063 handle_system_exit();
1065 PyErr_Fetch(&exception2
, &v2
, &tb2
);
1066 PyErr_NormalizeException(&exception2
, &v2
, &tb2
);
1070 PySys_WriteStderr("Error in sys.excepthook:\n");
1071 PyErr_Display(exception2
, v2
, tb2
);
1072 PySys_WriteStderr("\nOriginal exception was:\n");
1073 PyErr_Display(exception
, v
, tb
);
1074 Py_XDECREF(exception2
);
1081 PySys_WriteStderr("sys.excepthook is missing\n");
1082 PyErr_Display(exception
, v
, tb
);
1084 Py_XDECREF(exception
);
1090 PyErr_Display(PyObject
*exception
, PyObject
*value
, PyObject
*tb
)
1093 PyObject
*f
= PySys_GetObject("stderr");
1096 fprintf(stderr
, "lost sys.stderr\n");
1101 if (tb
&& tb
!= Py_None
)
1102 err
= PyTraceBack_Print(tb
, f
);
1104 PyObject_HasAttrString(value
, "print_file_and_line"))
1107 const char *filename
, *text
;
1109 if (!parse_syntax_error(value
, &message
, &filename
,
1110 &lineno
, &offset
, &text
))
1114 PyFile_WriteString(" File \"", f
);
1115 if (filename
== NULL
)
1116 PyFile_WriteString("<string>", f
);
1118 PyFile_WriteString(filename
, f
);
1119 PyFile_WriteString("\", line ", f
);
1120 PyOS_snprintf(buf
, sizeof(buf
), "%d", lineno
);
1121 PyFile_WriteString(buf
, f
);
1122 PyFile_WriteString("\n", f
);
1124 print_error_text(f
, offset
, text
);
1127 /* Can't be bothered to check all those
1128 PyFile_WriteString() calls */
1129 if (PyErr_Occurred())
1134 /* Don't do anything else */
1136 else if (PyExceptionClass_Check(exception
)) {
1137 PyObject
* moduleName
;
1138 char* className
= PyExceptionClass_Name(exception
);
1139 if (className
!= NULL
) {
1140 char *dot
= strrchr(className
, '.');
1145 moduleName
= PyObject_GetAttrString(exception
, "__module__");
1146 if (moduleName
== NULL
)
1147 err
= PyFile_WriteString("<unknown>", f
);
1149 char* modstr
= PyString_AsString(moduleName
);
1150 if (modstr
&& strcmp(modstr
, "exceptions"))
1152 err
= PyFile_WriteString(modstr
, f
);
1153 err
+= PyFile_WriteString(".", f
);
1155 Py_DECREF(moduleName
);
1158 if (className
== NULL
)
1159 err
= PyFile_WriteString("<unknown>", f
);
1161 err
= PyFile_WriteString(className
, f
);
1165 err
= PyFile_WriteObject(exception
, f
, Py_PRINT_RAW
);
1166 if (err
== 0 && (value
!= Py_None
)) {
1167 PyObject
*s
= PyObject_Str(value
);
1168 /* only print colon if the str() of the
1169 object is not the empty string
1173 else if (!PyString_Check(s
) ||
1174 PyString_GET_SIZE(s
) != 0)
1175 err
= PyFile_WriteString(": ", f
);
1177 err
= PyFile_WriteObject(s
, f
, Py_PRINT_RAW
);
1181 err
= PyFile_WriteString("\n", f
);
1184 /* If an error happened here, don't show it.
1185 XXX This is wrong, but too many callers rely on this behavior. */
1191 PyRun_StringFlags(const char *str
, int start
, PyObject
*globals
,
1192 PyObject
*locals
, PyCompilerFlags
*flags
)
1194 PyObject
*ret
= NULL
;
1195 PyArena
*arena
= PyArena_New();
1196 mod_ty mod
= PyParser_ASTFromString(str
, "<string>", start
, flags
,
1199 ret
= run_mod(mod
, "<string>", globals
, locals
, flags
, arena
);
1200 PyArena_Free(arena
);
1205 PyRun_FileExFlags(FILE *fp
, const char *filename
, int start
, PyObject
*globals
,
1206 PyObject
*locals
, int closeit
, PyCompilerFlags
*flags
)
1209 PyArena
*arena
= PyArena_New();
1210 mod_ty mod
= PyParser_ASTFromFile(fp
, filename
, start
, 0, 0,
1211 flags
, NULL
, arena
);
1213 PyArena_Free(arena
);
1218 ret
= run_mod(mod
, filename
, globals
, locals
, flags
, arena
);
1219 PyArena_Free(arena
);
1224 run_mod(mod_ty mod
, const char *filename
, PyObject
*globals
, PyObject
*locals
,
1225 PyCompilerFlags
*flags
, PyArena
*arena
)
1229 co
= PyAST_Compile(mod
, filename
, flags
, arena
);
1232 v
= PyEval_EvalCode(co
, globals
, locals
);
1238 run_pyc_file(FILE *fp
, const char *filename
, PyObject
*globals
,
1239 PyObject
*locals
, PyCompilerFlags
*flags
)
1244 long PyImport_GetMagicNumber(void);
1246 magic
= PyMarshal_ReadLongFromFile(fp
);
1247 if (magic
!= PyImport_GetMagicNumber()) {
1248 PyErr_SetString(PyExc_RuntimeError
,
1249 "Bad magic number in .pyc file");
1252 (void) PyMarshal_ReadLongFromFile(fp
);
1253 v
= PyMarshal_ReadLastObjectFromFile(fp
);
1255 if (v
== NULL
|| !PyCode_Check(v
)) {
1257 PyErr_SetString(PyExc_RuntimeError
,
1258 "Bad code object in .pyc file");
1261 co
= (PyCodeObject
*)v
;
1262 v
= PyEval_EvalCode(co
, globals
, locals
);
1264 flags
->cf_flags
|= (co
->co_flags
& PyCF_MASK
);
1270 Py_CompileStringFlags(const char *str
, const char *filename
, int start
,
1271 PyCompilerFlags
*flags
)
1274 PyArena
*arena
= PyArena_New();
1275 mod_ty mod
= PyParser_ASTFromString(str
, filename
, start
, flags
, arena
);
1277 PyArena_Free(arena
);
1280 if (flags
&& (flags
->cf_flags
& PyCF_ONLY_AST
)) {
1281 PyObject
*result
= PyAST_mod2obj(mod
);
1282 PyArena_Free(arena
);
1285 co
= PyAST_Compile(mod
, filename
, flags
, arena
);
1286 PyArena_Free(arena
);
1287 return (PyObject
*)co
;
1291 Py_SymtableString(const char *str
, const char *filename
, int start
)
1293 struct symtable
*st
;
1294 PyArena
*arena
= PyArena_New();
1295 mod_ty mod
= PyParser_ASTFromString(str
, filename
, start
, NULL
, arena
);
1297 PyArena_Free(arena
);
1300 st
= PySymtable_Build(mod
, filename
, 0);
1301 PyArena_Free(arena
);
1305 /* Preferred access to parser is through AST. */
1307 PyParser_ASTFromString(const char *s
, const char *filename
, int start
,
1308 PyCompilerFlags
*flags
, PyArena
*arena
)
1312 node
*n
= PyParser_ParseStringFlagsFilename(s
, filename
,
1313 &_PyParser_Grammar
, start
, &err
,
1314 PARSER_FLAGS(flags
));
1316 mod
= PyAST_FromNode(n
, flags
, filename
, arena
);
1327 PyParser_ASTFromFile(FILE *fp
, const char *filename
, int start
, char *ps1
,
1328 char *ps2
, PyCompilerFlags
*flags
, int *errcode
,
1333 node
*n
= PyParser_ParseFileFlags(fp
, filename
, &_PyParser_Grammar
,
1334 start
, ps1
, ps2
, &err
, PARSER_FLAGS(flags
));
1336 mod
= PyAST_FromNode(n
, flags
, filename
, arena
);
1343 *errcode
= err
.error
;
1348 /* Simplified interface to parsefile -- return node or set exception */
1351 PyParser_SimpleParseFileFlags(FILE *fp
, const char *filename
, int start
, int flags
)
1354 node
*n
= PyParser_ParseFileFlags(fp
, filename
, &_PyParser_Grammar
,
1355 start
, NULL
, NULL
, &err
, flags
);
1362 /* Simplified interface to parsestring -- return node or set exception */
1365 PyParser_SimpleParseStringFlags(const char *str
, int start
, int flags
)
1368 node
*n
= PyParser_ParseStringFlags(str
, &_PyParser_Grammar
,
1369 start
, &err
, flags
);
1376 PyParser_SimpleParseStringFlagsFilename(const char *str
, const char *filename
,
1377 int start
, int flags
)
1380 node
*n
= PyParser_ParseStringFlagsFilename(str
, filename
,
1381 &_PyParser_Grammar
, start
, &err
, flags
);
1388 PyParser_SimpleParseStringFilename(const char *str
, const char *filename
, int start
)
1390 return PyParser_SimpleParseStringFlagsFilename(str
, filename
, start
, 0);
1393 /* May want to move a more generalized form of this to parsetok.c or
1394 even parser modules. */
1397 PyParser_SetError(perrdetail
*err
)
1402 /* Set the error appropriate to the given input error code (see errcode.h) */
1405 err_input(perrdetail
*err
)
1407 PyObject
*v
, *w
, *errtype
;
1410 errtype
= PyExc_SyntaxError
;
1411 switch (err
->error
) {
1413 errtype
= PyExc_IndentationError
;
1414 if (err
->expected
== INDENT
)
1415 msg
= "expected an indented block";
1416 else if (err
->token
== INDENT
)
1417 msg
= "unexpected indent";
1418 else if (err
->token
== DEDENT
)
1419 msg
= "unexpected unindent";
1421 errtype
= PyExc_SyntaxError
;
1422 msg
= "invalid syntax";
1426 msg
= "invalid token";
1429 msg
= "EOF while scanning triple-quoted string";
1432 msg
= "EOL while scanning single-quoted string";
1435 if (!PyErr_Occurred())
1436 PyErr_SetNone(PyExc_KeyboardInterrupt
);
1442 msg
= "unexpected EOF while parsing";
1445 errtype
= PyExc_TabError
;
1446 msg
= "inconsistent use of tabs and spaces in indentation";
1449 msg
= "expression too long";
1452 errtype
= PyExc_IndentationError
;
1453 msg
= "unindent does not match any outer indentation level";
1456 errtype
= PyExc_IndentationError
;
1457 msg
= "too many levels of indentation";
1460 PyObject
*type
, *value
, *tb
;
1461 PyErr_Fetch(&type
, &value
, &tb
);
1462 if (value
!= NULL
) {
1463 u
= PyObject_Str(value
);
1465 msg
= PyString_AsString(u
);
1469 msg
= "unknown decode error";
1476 msg
= "unexpected character after line continuation character";
1479 fprintf(stderr
, "error=%d\n", err
->error
);
1480 msg
= "unknown parsing error";
1483 v
= Py_BuildValue("(ziiz)", err
->filename
,
1484 err
->lineno
, err
->offset
, err
->text
);
1485 if (err
->text
!= NULL
) {
1486 PyObject_FREE(err
->text
);
1491 w
= Py_BuildValue("(sO)", msg
, v
);
1494 PyErr_SetObject(errtype
, w
);
1498 /* Print fatal error message and abort */
1501 Py_FatalError(const char *msg
)
1503 fprintf(stderr
, "Fatal Python error: %s\n", msg
);
1505 OutputDebugString("Fatal Python error: ");
1506 OutputDebugString(msg
);
1507 OutputDebugString("\n");
1511 #endif /* MS_WINDOWS */
1515 /* Clean up and exit */
1518 #include "pythread.h"
1521 #define NEXITFUNCS 32
1522 static void (*exitfuncs
[NEXITFUNCS
])(void);
1523 static int nexitfuncs
= 0;
1525 int Py_AtExit(void (*func
)(void))
1527 if (nexitfuncs
>= NEXITFUNCS
)
1529 exitfuncs
[nexitfuncs
++] = func
;
1534 call_sys_exitfunc(void)
1536 PyObject
*exitfunc
= PySys_GetObject("exitfunc");
1540 Py_INCREF(exitfunc
);
1541 PySys_SetObject("exitfunc", (PyObject
*)NULL
);
1542 res
= PyEval_CallObject(exitfunc
, (PyObject
*)NULL
);
1544 if (!PyErr_ExceptionMatches(PyExc_SystemExit
)) {
1545 PySys_WriteStderr("Error in sys.exitfunc:\n");
1549 Py_DECREF(exitfunc
);
1557 call_ll_exitfuncs(void)
1559 while (nexitfuncs
> 0)
1560 (*exitfuncs
[--nexitfuncs
])();
1578 PyOS_setsig(SIGPIPE
, SIG_IGN
);
1581 PyOS_setsig(SIGXFZ
, SIG_IGN
);
1584 PyOS_setsig(SIGXFSZ
, SIG_IGN
);
1586 PyOS_InitInterrupts(); /* May imply initsignal() */
1591 * The file descriptor fd is considered ``interactive'' if either
1592 * a) isatty(fd) is TRUE, or
1593 * b) the -i flag was given, and the filename associated with
1594 * the descriptor is NULL or "<stdin>" or "???".
1597 Py_FdIsInteractive(FILE *fp
, const char *filename
)
1599 if (isatty((int)fileno(fp
)))
1601 if (!Py_InteractiveFlag
)
1603 return (filename
== NULL
) ||
1604 (strcmp(filename
, "<stdin>") == 0) ||
1605 (strcmp(filename
, "???") == 0);
1609 #if defined(USE_STACKCHECK)
1610 #if defined(WIN32) && defined(_MSC_VER)
1612 /* Stack checking for Microsoft C */
1618 * Return non-zero when we run out of memory on the stack; zero otherwise.
1621 PyOS_CheckStack(void)
1624 /* alloca throws a stack overflow exception if there's
1625 not enough space left on the stack */
1626 alloca(PYOS_STACK_MARGIN
* sizeof(void*));
1628 } __except (EXCEPTION_EXECUTE_HANDLER
) {
1629 /* just ignore all errors */
1634 #endif /* WIN32 && _MSC_VER */
1636 /* Alternate implementations can be added here... */
1638 #endif /* USE_STACKCHECK */
1641 /* Wrappers around sigaction() or signal(). */
1644 PyOS_getsig(int sig
)
1646 #ifdef HAVE_SIGACTION
1647 struct sigaction context
;
1648 if (sigaction(sig
, NULL
, &context
) == -1)
1650 return context
.sa_handler
;
1652 PyOS_sighandler_t handler
;
1653 /* Special signal handling for the secure CRT in Visual Studio 2005 */
1654 #if defined(_MSC_VER) && _MSC_VER >= 1400
1656 /* Only these signals are valid */
1665 /* Don't call signal() with other values or it will assert */
1669 #endif /* _MSC_VER && _MSC_VER >= 1400 */
1670 handler
= signal(sig
, SIG_IGN
);
1671 if (handler
!= SIG_ERR
)
1672 signal(sig
, handler
);
1678 PyOS_setsig(int sig
, PyOS_sighandler_t handler
)
1680 #ifdef HAVE_SIGACTION
1681 struct sigaction context
, ocontext
;
1682 context
.sa_handler
= handler
;
1683 sigemptyset(&context
.sa_mask
);
1684 context
.sa_flags
= 0;
1685 if (sigaction(sig
, &context
, &ocontext
) == -1)
1687 return ocontext
.sa_handler
;
1689 PyOS_sighandler_t oldhandler
;
1690 oldhandler
= signal(sig
, handler
);
1691 #ifdef HAVE_SIGINTERRUPT
1692 siginterrupt(sig
, 1);
1698 /* Deprecated C API functions still provided for binary compatiblity */
1700 #undef PyParser_SimpleParseFile
1702 PyParser_SimpleParseFile(FILE *fp
, const char *filename
, int start
)
1704 return PyParser_SimpleParseFileFlags(fp
, filename
, start
, 0);
1707 #undef PyParser_SimpleParseString
1709 PyParser_SimpleParseString(const char *str
, int start
)
1711 return PyParser_SimpleParseStringFlags(str
, start
, 0);
1714 #undef PyRun_AnyFile
1716 PyRun_AnyFile(FILE *fp
, const char *name
)
1718 return PyRun_AnyFileExFlags(fp
, name
, 0, NULL
);
1721 #undef PyRun_AnyFileEx
1723 PyRun_AnyFileEx(FILE *fp
, const char *name
, int closeit
)
1725 return PyRun_AnyFileExFlags(fp
, name
, closeit
, NULL
);
1728 #undef PyRun_AnyFileFlags
1730 PyRun_AnyFileFlags(FILE *fp
, const char *name
, PyCompilerFlags
*flags
)
1732 return PyRun_AnyFileExFlags(fp
, name
, 0, flags
);
1736 PyAPI_FUNC(PyObject
*)
1737 PyRun_File(FILE *fp
, const char *p
, int s
, PyObject
*g
, PyObject
*l
)
1739 return PyRun_FileExFlags(fp
, p
, s
, g
, l
, 0, NULL
);
1743 PyAPI_FUNC(PyObject
*)
1744 PyRun_FileEx(FILE *fp
, const char *p
, int s
, PyObject
*g
, PyObject
*l
, int c
)
1746 return PyRun_FileExFlags(fp
, p
, s
, g
, l
, c
, NULL
);
1749 #undef PyRun_FileFlags
1750 PyAPI_FUNC(PyObject
*)
1751 PyRun_FileFlags(FILE *fp
, const char *p
, int s
, PyObject
*g
, PyObject
*l
,
1752 PyCompilerFlags
*flags
)
1754 return PyRun_FileExFlags(fp
, p
, s
, g
, l
, 0, flags
);
1757 #undef PyRun_SimpleFile
1759 PyRun_SimpleFile(FILE *f
, const char *p
)
1761 return PyRun_SimpleFileExFlags(f
, p
, 0, NULL
);
1764 #undef PyRun_SimpleFileEx
1766 PyRun_SimpleFileEx(FILE *f
, const char *p
, int c
)
1768 return PyRun_SimpleFileExFlags(f
, p
, c
, NULL
);
1773 PyAPI_FUNC(PyObject
*)
1774 PyRun_String(const char *str
, int s
, PyObject
*g
, PyObject
*l
)
1776 return PyRun_StringFlags(str
, s
, g
, l
, NULL
);
1779 #undef PyRun_SimpleString
1781 PyRun_SimpleString(const char *s
)
1783 return PyRun_SimpleStringFlags(s
, NULL
);
1786 #undef Py_CompileString
1787 PyAPI_FUNC(PyObject
*)
1788 Py_CompileString(const char *str
, const char *p
, int s
)
1790 return Py_CompileStringFlags(str
, p
, s
, NULL
);
1793 #undef PyRun_InteractiveOne
1795 PyRun_InteractiveOne(FILE *f
, const char *p
)
1797 return PyRun_InteractiveOneFlags(f
, p
, NULL
);
1800 #undef PyRun_InteractiveLoop
1802 PyRun_InteractiveLoop(FILE *f
, const char *p
)
1804 return PyRun_InteractiveLoopFlags(f
, p
, NULL
);