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