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

Last change on this file was 3225, checked in by bird, 18 years ago

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