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