History

boot/pc: PBS now calculates rootdir offset itself

ment committed 15 years ago

Commit 6964eaeNo parent (first commit)18796 files · +4483044 −-3999Browse files

Showing the changes to sys/src/cmd/python/Python/pythonrun.c (1 of 18796 files). Show all

Unified · Split

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