source: python/vendor/current/Python/pythonrun.c

Last change on this file was 388, checked in by dmik, 11 years ago

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