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