Python/pythonrun.c

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