1 

     2 /* Python interpreter top-level routines, including init/exit */

     3 

     4 #include "Python.h"

     5 

     6 #include "Python-ast.h"

     7 #undef Yield /* undefine macro conflicting with winbase.h */

     8 #include "grammar.h"

     9 #include "node.h"

    10 #include "token.h"

    11 #include "parsetok.h"

    12 #include "errcode.h"

    13 #include "code.h"

    14 #include "compile.h"

    15 #include "symtable.h"

    16 #include "pyarena.h"

    17 #include "ast.h"

    18 #include "eval.h"

    19 #include "marshal.h"

    20 

    21 #ifdef HAVE_SIGNAL_H

    22 #include <signal.h>

    23 #endif

    24 

    25 #ifdef HAVE_LANGINFO_H

    26 #include <locale.h>

    27 #include <langinfo.h>

    28 #endif

    29 

    30 #ifdef MS_WINDOWS

    31 #undef BYTE

    32 #include "windows.h"

    33 #endif

    34 

    35 #ifndef Py_REF_DEBUG

    36 #define PRINT_TOTAL_REFS()

    37 #else /* Py_REF_DEBUG */

    38 #define PRINT_TOTAL_REFS() fprintf(stderr,				\

    39 				   "[%" PY_FORMAT_SIZE_T "d refs]\n",	\

    40 				   _Py_GetRefTotal())

    41 #endif

    42 

    43 #ifdef __cplusplus

    44 extern "C" {

    45 #endif

    46 

    47 extern char *Py_GetPath(void);

    48 

    49 extern grammar _PyParser_Grammar; /* From graminit.c */

    50 

    51 /* Forward */

    52 static void initmain(void);

    53 static void initsite(void);

    54 static PyObject *run_mod(mod_ty, const char *, PyObject *, PyObject *,

    55 			  PyCompilerFlags *, PyArena *);

    56 static PyObject *run_pyc_file(FILE *, const char *, PyObject *, PyObject *,

    57 			      PyCompilerFlags *);

    58 static void err_input(perrdetail *);

    59 static void initsigs(void);

    60 static void call_sys_exitfunc(void);

    61 static void call_ll_exitfuncs(void);

    62 extern void _PyUnicode_Init(void);

    63 extern void _PyUnicode_Fini(void);

    64 

    65 #ifdef WITH_THREAD

    66 extern void _PyGILState_Init(PyInterpreterState *, PyThreadState *);

    67 extern void _PyGILState_Fini(void);

    68 #endif /* WITH_THREAD */

    69 

    70 int Py_DebugFlag; /* Needed by parser.c */

    71 int Py_VerboseFlag; /* Needed by import.c */

    72 int Py_InteractiveFlag; /* Needed by Py_FdIsInteractive() below */

    73 int Py_InspectFlag; /* Needed to determine whether to exit at SystemError */

    74 int Py_NoSiteFlag; /* Suppress 'import site' */

    75 int Py_BytesWarningFlag; /* Warn on str(bytes) and str(buffer) */

    76 int Py_DontWriteBytecodeFlag; /* Suppress writing bytecode files (*.py[co]) */

    77 int Py_UseClassExceptionsFlag = 1; /* Needed by bltinmodule.c: deprecated */

    78 int Py_FrozenFlag; /* Needed by getpath.c */

    79 int Py_UnicodeFlag = 0; /* Needed by compile.c */

    80 int Py_IgnoreEnvironmentFlag; /* e.g. PYTHONPATH, PYTHONHOME */

    81 /* _XXX Py_QnewFlag should go away in 2.3.  It's true iff -Qnew is passed,

    82   on the command line, and is used in 2.2 by ceval.c to make all "/" divisions

    83   true divisions (which they will be in 2.3). */

    84 int _Py_QnewFlag = 0;

    85 int Py_NoUserSiteDirectory = 0; /* for -s and site.py */

    86 

    87 /* PyModule_GetWarningsModule is no longer necessary as of 2.6

    88 since _warnings is builtin.  This API should not be used. */

    89 PyObject *

    90 PyModule_GetWarningsModule(void)

    91 {

    92 	return PyImport_ImportModule("warnings");

    93 }

    94 

    95 static int initialized = 0;

    96 

    97 /* API to access the initialized flag -- useful for esoteric use */

    98 

    99 int

   100 Py_IsInitialized(void)

   101 {

   102 	return initialized;

   103 }

   104 

   105 /* Global initializations.  Can be undone by Py_Finalize().  Don't

   106    call this twice without an intervening Py_Finalize() call.  When

   107    initializations fail, a fatal error is issued and the function does

   108    not return.  On return, the first thread and interpreter state have

   109    been created.

   110 

   111    Locking: you must hold the interpreter lock while calling this.

   112    (If the lock has not yet been initialized, that's equivalent to

   113    having the lock, but you cannot use multiple threads.)

   114 

   115 */

   116 

   117 static int

   118 add_flag(int flag, const char *envs)

   119 {

   120 	int env = atoi(envs);

   121 	if (flag < env)

   122 		flag = env;

   123 	if (flag < 1)

   124 		flag = 1;

   125 	return flag;

   126 }

   127 

   128 void

   129 Py_InitializeEx(int install_sigs)

   130 {

   131 	PyInterpreterState *interp;

   132 	PyThreadState *tstate;

   133 	PyObject *bimod, *sysmod;

   134 	char *p;

   135 	char *icodeset = NULL; /* On Windows, input codeset may theoretically 

   136 			          differ from output codeset. */

   137 	char *codeset = NULL;

   138 	char *errors = NULL;

   139 	int free_codeset = 0;

   140 	int overridden = 0;

   141 	PyObject *sys_stream, *sys_isatty;

   142 #if defined(Py_USING_UNICODE) && defined(HAVE_LANGINFO_H) && defined(CODESET)

   143 	char *saved_locale, *loc_codeset;

   144 #endif

   145 #ifdef MS_WINDOWS

   146 	char ibuf[128];

   147 	char buf[128];

   148 #endif

   149 	extern void _Py_ReadyTypes(void);

   150 

   151 	if (initialized)

   152 		return;

   153 	initialized = 1;

   154 

   155 	if ((p = Py_GETENV("PYTHONDEBUG")) && *p != '\0')

   156 		Py_DebugFlag = add_flag(Py_DebugFlag, p);

   157 	if ((p = Py_GETENV("PYTHONVERBOSE")) && *p != '\0')

   158 		Py_VerboseFlag = add_flag(Py_VerboseFlag, p);

   159 	if ((p = Py_GETENV("PYTHONOPTIMIZE")) && *p != '\0')

   160 		Py_OptimizeFlag = add_flag(Py_OptimizeFlag, p);

   161 	if ((p = Py_GETENV("PYTHONDONTWRITEBYTECODE")) && *p != '\0')

   162 		Py_DontWriteBytecodeFlag = add_flag(Py_DontWriteBytecodeFlag, p);

   163 

   164 	interp = PyInterpreterState_New();

   165 	if (interp == NULL)

   166 		Py_FatalError("Py_Initialize: can't make first interpreter");

   167 

   168 	tstate = PyThreadState_New(interp);

   169 	if (tstate == NULL)

   170 		Py_FatalError("Py_Initialize: can't make first thread");

   171 	(void) PyThreadState_Swap(tstate);

   172 

   173 	_Py_ReadyTypes();

   174 

   175 	if (!_PyFrame_Init())

   176 		Py_FatalError("Py_Initialize: can't init frames");

   177 

   178 	if (!_PyInt_Init())

   179 		Py_FatalError("Py_Initialize: can't init ints");

   180 

   181 	if (!PyByteArray_Init())

   182 		Py_FatalError("Py_Initialize: can't init bytearray");

   183 

   184 	_PyFloat_Init();

   185 

   186 	interp->modules = PyDict_New();

   187 	if (interp->modules == NULL)

   188 		Py_FatalError("Py_Initialize: can't make modules dictionary");

   189 	interp->modules_reloading = PyDict_New();

   190 	if (interp->modules_reloading == NULL)

   191 		Py_FatalError("Py_Initialize: can't make modules_reloading dictionary");

   192 

   193 #ifdef Py_USING_UNICODE

   194 	/* Init Unicode implementation; relies on the codec registry */

   195 	_PyUnicode_Init();

   196 #endif

   197 

   198 	bimod = _PyBuiltin_Init();

   199 	if (bimod == NULL)

   200 		Py_FatalError("Py_Initialize: can't initialize __builtin__");

   201 	interp->builtins = PyModule_GetDict(bimod);

   202 	if (interp->builtins == NULL)

   203 		Py_FatalError("Py_Initialize: can't initialize builtins dict");

   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 	if (interp->sysdict == NULL)

   211 		Py_FatalError("Py_Initialize: can't initialize sys dict");

   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 	/* Initialize warnings. */

   233 	_PyWarnings_Init();

   234 	if (PySys_HasWarnOptions()) {

   235 		PyObject *warnings_module = PyImport_ImportModule("warnings");

   236 		if (!warnings_module)

   237 			PyErr_Clear();

   238 		Py_XDECREF(warnings_module);

   239 	}

   240 

   241 	initmain(); /* Module __main__ */

   242 	if (!Py_NoSiteFlag)

   243 		initsite(); /* Module site */

   244 

   245 	/* auto-thread-state API, if available */

   246 #ifdef WITH_THREAD

   247 	_PyGILState_Init(interp, tstate);

   248 #endif /* WITH_THREAD */

   249 

   250 	if ((p = Py_GETENV("PYTHONIOENCODING")) && *p != '\0') {

   251 		p = icodeset = codeset = strdup(p);

   252 		free_codeset = 1;

   253 		errors = strchr(p, ':');

   254 		if (errors) {

   255 			*errors = '\0';

   256 			errors++;

   257 		}

   258 		overridden = 1;

   259 	}

   260 

   261 #if defined(Py_USING_UNICODE) && defined(HAVE_LANGINFO_H) && defined(CODESET)

   262 	/* On Unix, set the file system encoding according to the

   263 	   user's preference, if the CODESET names a well-known

   264 	   Python codec, and Py_FileSystemDefaultEncoding isn't

   265 	   initialized by other means. Also set the encoding of

   266 	   stdin and stdout if these are terminals, unless overridden.  */

   267 

   268 	if (!overridden || !Py_FileSystemDefaultEncoding) {

   269 		saved_locale = strdup(setlocale(LC_CTYPE, NULL));

   270 		setlocale(LC_CTYPE, "");

   271 		loc_codeset = nl_langinfo(CODESET);

   272 		if (loc_codeset && *loc_codeset) {

   273 			PyObject *enc = PyCodec_Encoder(loc_codeset);

   274 			if (enc) {

   275 				loc_codeset = strdup(loc_codeset);

   276 				Py_DECREF(enc);

   277 			} else {

   278 				loc_codeset = NULL;

   279 				PyErr_Clear();

   280 			}

   281 		} else

   282 			loc_codeset = NULL;

   283 		setlocale(LC_CTYPE, saved_locale);

   284 		free(saved_locale);

   285 

   286 		if (!overridden) {

   287 			codeset = icodeset = loc_codeset;

   288 			free_codeset = 1;

   289 		}

   290 

   291 		/* Initialize Py_FileSystemDefaultEncoding from

   292 		   locale even if PYTHONIOENCODING is set. */

   293 		if (!Py_FileSystemDefaultEncoding) {

   294 			Py_FileSystemDefaultEncoding = loc_codeset;

   295 			if (!overridden)

   296 				free_codeset = 0;

   297 		}

   298 	}

   299 #endif

   300 

   301 #ifdef MS_WINDOWS

   302 	if (!overridden) {

   303 		icodeset = ibuf;

   304 		codeset = buf;

   305 		sprintf(ibuf, "cp%d", GetConsoleCP());

   306 		sprintf(buf, "cp%d", GetConsoleOutputCP());

   307 	}

   308 #endif

   309 

   310 	if (codeset) {

   311 		sys_stream = PySys_GetObject("stdin");

   312 		sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");

   313 		if (!sys_isatty)

   314 			PyErr_Clear();

   315 		if ((overridden ||

   316 		     (sys_isatty && PyObject_IsTrue(sys_isatty))) &&

   317 		   PyFile_Check(sys_stream)) {

   318 			if (!PyFile_SetEncodingAndErrors(sys_stream, icodeset, errors))

   319 				Py_FatalError("Cannot set codeset of stdin");

   320 		}

   321 		Py_XDECREF(sys_isatty);

   322 

   323 		sys_stream = PySys_GetObject("stdout");

   324 		sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");

   325 		if (!sys_isatty)

   326 			PyErr_Clear();

   327 		if ((overridden || 

   328 		     (sys_isatty && PyObject_IsTrue(sys_isatty))) &&

   329 		   PyFile_Check(sys_stream)) {

   330 			if (!PyFile_SetEncodingAndErrors(sys_stream, codeset, errors))

   331 				Py_FatalError("Cannot set codeset of stdout");

   332 		}

   333 		Py_XDECREF(sys_isatty);

   334 

   335 		sys_stream = PySys_GetObject("stderr");

   336 		sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");

   337 		if (!sys_isatty)

   338 			PyErr_Clear();

   339 		if((overridden || 

   340 		    (sys_isatty && PyObject_IsTrue(sys_isatty))) &&

   341 		   PyFile_Check(sys_stream)) {

   342 			if (!PyFile_SetEncodingAndErrors(sys_stream, codeset, errors))

   343 				Py_FatalError("Cannot set codeset of stderr");

   344 		}

   345 		Py_XDECREF(sys_isatty);

   346 

   347 		if (free_codeset)

   348 			free(codeset);

   349 	}

   350 }

   351 

   352 void

   353 Py_Initialize(void)

   354 {

   355 	Py_InitializeEx(1);

   356 }

   357 

   358 

   359 #ifdef COUNT_ALLOCS

   360 extern void dump_counts(FILE*);

   361 #endif

   362 

   363 /* Undo the effect of Py_Initialize().

   364 

   365    Beware: if multiple interpreter and/or thread states exist, these

   366    are not wiped out; only the current thread and interpreter state

   367    are deleted.  But since everything else is deleted, those other

   368    interpreter and thread states should no longer be used.

   369 

   370    (XXX We should do better, e.g. wipe out all interpreters and

   371    threads.)

   372 

   373    Locking: as above.

   374 

   375 */

   376 

   377 void

   378 Py_Finalize(void)

   379 {

   380 	PyInterpreterState *interp;

   381 	PyThreadState *tstate;

   382 

   383 	if (!initialized)

   384 		return;

   385 

   386 	/* The interpreter is still entirely intact at this point, and the

   387 	 * exit funcs may be relying on that.  In particular, if some thread

   388 	 * or exit func is still waiting to do an import, the import machinery

   389 	 * expects Py_IsInitialized() to return true.  So don't say the

   390 	 * interpreter is uninitialized until after the exit funcs have run.

   391 	 * Note that Threading.py uses an exit func to do a join on all the

   392 	 * threads created thru it, so this also protects pending imports in

   393 	 * the threads created via Threading.

   394 	 */

   395 	call_sys_exitfunc();

   396 	initialized = 0;

   397 

   398 	/* Get current thread state and interpreter pointer */

   399 	tstate = PyThreadState_GET();

   400 	interp = tstate->interp;

   401 

   402 	/* Disable signal handling */

   403 	PyOS_FiniInterrupts();

   404 

   405 	/* Clear type lookup cache */

   406 	PyType_ClearCache();

   407 

   408 	/* Collect garbage.  This may call finalizers; it's nice to call these

   409 	 * before all modules are destroyed.

   410 	 * XXX If a __del__ or weakref callback is triggered here, and tries to

   411 	 * XXX import a module, bad things can happen, because Python no

   412 	 * XXX longer believes it's initialized.

   413 	 * XXX     Fatal Python error: Interpreter not initialized (version mismatch?)

   414 	 * XXX is easy to provoke that way.  I've also seen, e.g.,

   415 	 * XXX     Exception exceptions.ImportError: 'No module named sha'

   416 	 * XXX         in <function callback at 0x008F5718> ignored

   417 	 * XXX but I'm unclear on exactly how that one happens.  In any case,

   418 	 * XXX I haven't seen a real-life report of either of these.

   419 	 */

   420 	PyGC_Collect();

   421 #ifdef COUNT_ALLOCS

   422 	/* With COUNT_ALLOCS, it helps to run GC multiple times:

   423 	   each collection might release some types from the type

   424 	   list, so they become garbage. */

   425 	while (PyGC_Collect() > 0)

   426 		/* nothing */;

   427 #endif

   428 

   429 	/* Destroy all modules */

   430 	PyImport_Cleanup();

   431 

   432 	/* Collect final garbage.  This disposes of cycles created by

   433 	 * new-style class definitions, for example.

   434 	 * XXX This is disabled because it caused too many problems.  If

   435 	 * XXX a __del__ or weakref callback triggers here, Python code has

   436 	 * XXX a hard time running, because even the sys module has been

   437 	 * XXX cleared out (sys.stdout is gone, sys.excepthook is gone, etc).

   438 	 * XXX One symptom is a sequence of information-free messages

   439 	 * XXX coming from threads (if a __del__ or callback is invoked,

   440 	 * XXX other threads can execute too, and any exception they encounter

   441 	 * XXX triggers a comedy of errors as subsystem after subsystem

   442 	 * XXX fails to find what it *expects* to find in sys to help report

   443 	 * XXX the exception and consequent unexpected failures).  I've also

   444 	 * XXX seen segfaults then, after adding print statements to the

   445 	 * XXX Python code getting called.

   446 	 */

   447 #if 0

   448 	PyGC_Collect();

   449 #endif

   450 

   451 	/* Destroy the database used by _PyImport_{Fixup,Find}Extension */

   452 	_PyImport_Fini();

   453 

   454 	/* Debugging stuff */

   455 #ifdef COUNT_ALLOCS

   456 	dump_counts(stdout);

   457 #endif

   458 

   459 	PRINT_TOTAL_REFS();

   460 

   461 #ifdef Py_TRACE_REFS

   462 	/* Display all objects still alive -- this can invoke arbitrary

   463 	 * __repr__ overrides, so requires a mostly-intact interpreter.

   464 	 * Alas, a lot of stuff may still be alive now that will be cleaned

   465 	 * up later.

   466 	 */

   467 	if (Py_GETENV("PYTHONDUMPREFS"))

   468 		_Py_PrintReferences(stderr);

   469 #endif /* Py_TRACE_REFS */

   470 

   471 	/* Clear interpreter state */

   472 	PyInterpreterState_Clear(interp);

   473 

   474 	/* Now we decref the exception classes.  After this point nothing

   475 	   can raise an exception.  That's okay, because each Fini() method

   476 	   below has been checked to make sure no exceptions are ever

   477 	   raised.

   478 	*/

   479 

   480 	_PyExc_Fini();

   481 

   482 	/* Cleanup auto-thread-state */

   483 #ifdef WITH_THREAD

   484 	_PyGILState_Fini();

   485 #endif /* WITH_THREAD */

   486 

   487 	/* Delete current thread */

   488 	PyThreadState_Swap(NULL);

   489 	PyInterpreterState_Delete(interp);

   490 

   491 	/* Sundry finalizers */

   492 	PyMethod_Fini();

   493 	PyFrame_Fini();

   494 	PyCFunction_Fini();

   495 	PyTuple_Fini();

   496 	PyList_Fini();

   497 	PySet_Fini();

   498 	PyString_Fini();

   499 	PyByteArray_Fini();

   500 	PyInt_Fini();

   501 	PyFloat_Fini();

   502 	PyDict_Fini();

   503 

   504 #ifdef Py_USING_UNICODE

   505 	/* Cleanup Unicode implementation */

   506 	_PyUnicode_Fini();

   507 #endif

   508 

   509 	/* XXX Still allocated:

   510 	   - various static ad-hoc pointers to interned strings

   511 	   - int and float free list blocks

   512 	   - whatever various modules and libraries allocate

   513 	*/

   514 

   515 	PyGrammar_RemoveAccelerators(&_PyParser_Grammar);

   516 

   517 #ifdef Py_TRACE_REFS

   518 	/* Display addresses (& refcnts) of all objects still alive.

   519 	 * An address can be used to find the repr of the object, printed

   520 	 * above by _Py_PrintReferences.

   521 	 */

   522 	if (Py_GETENV("PYTHONDUMPREFS"))

   523 		_Py_PrintReferenceAddresses(stderr);

   524 #endif /* Py_TRACE_REFS */

   525 #ifdef PYMALLOC_DEBUG

   526 	if (Py_GETENV("PYTHONMALLOCSTATS"))

   527 		_PyObject_DebugMallocStats();

   528 #endif

   529 

   530 	call_ll_exitfuncs();

   531 }

   532 

   533 /* Create and initialize a new interpreter and thread, and return the

   534    new thread.  This requires that Py_Initialize() has been called

   535    first.

   536 

   537    Unsuccessful initialization yields a NULL pointer.  Note that *no*

   538    exception information is available even in this case -- the

   539    exception information is held in the thread, and there is no

   540    thread.

   541 

   542    Locking: as above.

   543 

   544 */

   545 

   546 PyThreadState *

   547 Py_NewInterpreter(void)

   548 {

   549 	PyInterpreterState *interp;

   550 	PyThreadState *tstate, *save_tstate;

   551 	PyObject *bimod, *sysmod;

   552 

   553 	if (!initialized)

   554 		Py_FatalError("Py_NewInterpreter: call Py_Initialize first");

   555 

   556 	interp = PyInterpreterState_New();

   557 	if (interp == NULL)

   558 		return NULL;

   559 

   560 	tstate = PyThreadState_New(interp);

   561 	if (tstate == NULL) {

   562 		PyInterpreterState_Delete(interp);

   563 		return NULL;

   564 	}

   565 

   566 	save_tstate = PyThreadState_Swap(tstate);

   567 

   568 	/* XXX The following is lax in error checking */

   569 

   570 	interp->modules = PyDict_New();

   571 	interp->modules_reloading = PyDict_New();

   572 

   573 	bimod = _PyImport_FindExtension("__builtin__", "__builtin__");

   574 	if (bimod != NULL) {

   575 		interp->builtins = PyModule_GetDict(bimod);

   576 		if (interp->builtins == NULL)

   577 			goto handle_error;

   578 		Py_INCREF(interp->builtins);

   579 	}

   580 	sysmod = _PyImport_FindExtension("sys", "sys");

   581 	if (bimod != NULL && sysmod != NULL) {

   582 		interp->sysdict = PyModule_GetDict(sysmod);

   583 		if (interp->sysdict == NULL)

   584 			goto handle_error;

   585 		Py_INCREF(interp->sysdict);

   586 		PySys_SetPath(Py_GetPath());

   587 		PyDict_SetItemString(interp->sysdict, "modules",

   588 				     interp->modules);

   589 		_PyImportHooks_Init();

   590 		initmain();

   591 		if (!Py_NoSiteFlag)

   592 			initsite();

   593 	}

   594 

   595 	if (!PyErr_Occurred())

   596 		return tstate;

   597 

   598 handle_error:

   599 	/* Oops, it didn't work.  Undo it all. */

   600 

   601 	PyErr_Print();

   602 	PyThreadState_Clear(tstate);

   603 	PyThreadState_Swap(save_tstate);

   604 	PyThreadState_Delete(tstate);

   605 	PyInterpreterState_Delete(interp);

   606 

   607 	return NULL;

   608 }

   609 

   610 /* Delete an interpreter and its last thread.  This requires that the

   611    given thread state is current, that the thread has no remaining

   612    frames, and that it is its interpreter's only remaining thread.

   613    It is a fatal error to violate these constraints.

   614 

   615    (Py_Finalize() doesn't have these constraints -- it zaps

   616    everything, regardless.)

   617 

   618    Locking: as above.

   619 

   620 */

   621 

   622 void

   623 Py_EndInterpreter(PyThreadState *tstate)

   624 {

   625 	PyInterpreterState *interp = tstate->interp;

   626 

   627 	if (tstate != PyThreadState_GET())

   628 		Py_FatalError("Py_EndInterpreter: thread is not current");

   629 	if (tstate->frame != NULL)

   630 		Py_FatalError("Py_EndInterpreter: thread still has a frame");

   631 	if (tstate != interp->tstate_head || tstate->next != NULL)

   632 		Py_FatalError("Py_EndInterpreter: not the last thread");

   633 

   634 	PyImport_Cleanup();

   635 	PyInterpreterState_Clear(interp);

   636 	PyThreadState_Swap(NULL);

   637 	PyInterpreterState_Delete(interp);

   638 }

   639 

   640 static char *progname = "python";

   641 

   642 void

   643 Py_SetProgramName(char *pn)

   644 {

   645 	if (pn && *pn)

   646 		progname = pn;

   647 }

   648 

   649 char *

   650 Py_GetProgramName(void)

   651 {

   652 	return progname;

   653 }

   654 

   655 static char *default_home = NULL;

   656 

   657 void

   658 Py_SetPythonHome(char *home)

   659 {

   660 	default_home = home;

   661 }

   662 

   663 char *

   664 Py_GetPythonHome(void)

   665 {

   666 	char *home = default_home;

   667 	if (home == NULL && !Py_IgnoreEnvironmentFlag)

   668 		home = Py_GETENV("PYTHONHOME");

   669 	return home;

   670 }

   671 

   672 /* Create __main__ module */

   673 

   674 static void

   675 initmain(void)

   676 {

   677 	PyObject *m, *d;

   678 	m = PyImport_AddModule("__main__");

   679 	if (m == NULL)

   680 		Py_FatalError("can't create __main__ module");

   681 	d = PyModule_GetDict(m);

   682 	if (PyDict_GetItemString(d, "__builtins__") == NULL) {

   683 		PyObject *bimod = PyImport_ImportModule("__builtin__");

   684 		if (bimod == NULL ||

   685 		    PyDict_SetItemString(d, "__builtins__", bimod) != 0)

   686 			Py_FatalError("can't add __builtins__ to __main__");

   687 		Py_DECREF(bimod);

   688 	}

   689 }

   690 

   691 /* Import the site module (not into __main__ though) */

   692 

   693 static void

   694 initsite(void)

   695 {

   696 	PyObject *m, *f;

   697 	m = PyImport_ImportModule("site");

   698 	if (m == NULL) {

   699 		f = PySys_GetObject("stderr");

   700 		if (Py_VerboseFlag) {

   701 			PyFile_WriteString(

   702 				"'import site' failed; traceback:\n", f);

   703 			PyErr_Print();

   704 		}

   705 		else {

   706 			PyFile_WriteString(

   707 			  "'import site' failed; use -v for traceback\n", f);

   708 			PyErr_Clear();

   709 		}

   710 	}

   711 	else {

   712 		Py_DECREF(m);

   713 	}

   714 }

   715 

   716 /* Parse input from a file and execute it */

   717 

   718 int

   719 PyRun_AnyFileExFlags(FILE *fp, const char *filename, int closeit,

   720 		     PyCompilerFlags *flags)

   721 {

   722 	if (filename == NULL)

   723 		filename = "???";

   724 	if (Py_FdIsInteractive(fp, filename)) {

   725 		int err = PyRun_InteractiveLoopFlags(fp, filename, flags);

   726 		if (closeit)

   727 			fclose(fp);

   728 		return err;

   729 	}

   730 	else

   731 		return PyRun_SimpleFileExFlags(fp, filename, closeit, flags);

   732 }

   733 

   734 int

   735 PyRun_InteractiveLoopFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)

   736 {

   737 	PyObject *v;

   738 	int ret;

   739 	PyCompilerFlags local_flags;

   740 

   741 	if (flags == NULL) {

   742 		flags = &local_flags;

   743 		local_flags.cf_flags = 0;

   744 	}

   745 	v = PySys_GetObject("ps1");

   746 	if (v == NULL) {

   747 		PySys_SetObject("ps1", v = PyString_FromString(">>> "));

   748 		Py_XDECREF(v);

   749 	}

   750 	v = PySys_GetObject("ps2");

   751 	if (v == NULL) {

   752 		PySys_SetObject("ps2", v = PyString_FromString("... "));

   753 		Py_XDECREF(v);

   754 	}

   755 	for (;;) {

   756 		ret = PyRun_InteractiveOneFlags(fp, filename, flags);

   757 		PRINT_TOTAL_REFS();

   758 		if (ret == E_EOF)

   759 			return 0;

   760 		/*

   761 		if (ret == E_NOMEM)

   762 			return -1;

   763 		*/

   764 	}

   765 }

   766 

   767 #if 0

   768 /* compute parser flags based on compiler flags */

   769 #define PARSER_FLAGS(flags) \

   770 	((flags) ? ((((flags)->cf_flags & PyCF_DONT_IMPLY_DEDENT) ? \

   771 		      PyPARSE_DONT_IMPLY_DEDENT : 0)) : 0)

   772 #endif

   773 #if 1

   774 /* Keep an example of flags with future keyword support. */

   775 #define PARSER_FLAGS(flags) \

   776 	((flags) ? ((((flags)->cf_flags & PyCF_DONT_IMPLY_DEDENT) ? \

   777 		      PyPARSE_DONT_IMPLY_DEDENT : 0) \

   778 		    | (((flags)->cf_flags & CO_FUTURE_PRINT_FUNCTION) ? \

   779 		       PyPARSE_PRINT_IS_FUNCTION : 0) \

   780 		    | (((flags)->cf_flags & CO_FUTURE_UNICODE_LITERALS) ? \

   781 		       PyPARSE_UNICODE_LITERALS : 0) \

   782 		    ) : 0)

   783 #endif

   784 

   785 int

   786 PyRun_InteractiveOneFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)

   787 {

   788 	PyObject *m, *d, *v, *w;

   789 	mod_ty mod;

   790 	PyArena *arena;

   791 	char *ps1 = "", *ps2 = "";

   792 	int errcode = 0;

   793 

   794 	v = PySys_GetObject("ps1");

   795 	if (v != NULL) {

   796 		v = PyObject_Str(v);

   797 		if (v == NULL)

   798 			PyErr_Clear();

   799 		else if (PyString_Check(v))

   800 			ps1 = PyString_AsString(v);

   801 	}

   802 	w = PySys_GetObject("ps2");

   803 	if (w != NULL) {

   804 		w = PyObject_Str(w);

   805 		if (w == NULL)

   806 			PyErr_Clear();

   807 		else if (PyString_Check(w))

   808 			ps2 = PyString_AsString(w);

   809 	}

   810 	arena = PyArena_New();

   811 	if (arena == NULL) {

   812 		Py_XDECREF(v);

   813 		Py_XDECREF(w);

   814 		return -1;

   815 	}

   816 	mod = PyParser_ASTFromFile(fp, filename,

   817 				   Py_single_input, ps1, ps2,

   818 				   flags, &errcode, arena);

   819 	Py_XDECREF(v);

   820 	Py_XDECREF(w);

   821 	if (mod == NULL) {

   822 		PyArena_Free(arena);

   823 		if (errcode == E_EOF) {

   824 			PyErr_Clear();

   825 			return E_EOF;

   826 		}

   827 		PyErr_Print();

   828 		return -1;

   829 	}

   830 	m = PyImport_AddModule("__main__");

   831 	if (m == NULL) {

   832 		PyArena_Free(arena);

   833 		return -1;

   834 	}

   835 	d = PyModule_GetDict(m);

   836 	v = run_mod(mod, filename, d, d, flags, arena);

   837 	PyArena_Free(arena);

   838 	if (v == NULL) {

   839 		PyErr_Print();

   840 		return -1;

   841 	}

   842 	Py_DECREF(v);

   843 	if (Py_FlushLine())

   844 		PyErr_Clear();

   845 	return 0;

   846 }

   847 

   848 /* Check whether a file maybe a pyc file: Look at the extension,

   849    the file type, and, if we may close it, at the first few bytes. */

   850 

   851 static int

   852 maybe_pyc_file(FILE *fp, const char* filename, const char* ext, int closeit)

   853 {

   854 	if (strcmp(ext, ".pyc") == 0 || strcmp(ext, ".pyo") == 0)

   855 		return 1;

   856 

   857 	/* Only look into the file if we are allowed to close it, since

   858 	   it then should also be seekable. */

   859 	if (closeit) {

   860 		/* Read only two bytes of the magic. If the file was opened in

   861 		   text mode, the bytes 3 and 4 of the magic (\r\n) might not

   862 		   be read as they are on disk. */

   863 		unsigned int halfmagic = PyImport_GetMagicNumber() & 0xFFFF;

   864 		unsigned char buf[2];

   865 		/* Mess:  In case of -x, the stream is NOT at its start now,

   866 		   and ungetc() was used to push back the first newline,

   867 		   which makes the current stream position formally undefined,

   868 		   and a x-platform nightmare.

   869 		   Unfortunately, we have no direct way to know whether -x

   870 		   was specified.  So we use a terrible hack:  if the current

   871 		   stream position is not 0, we assume -x was specified, and

   872 		   give up.  Bug 132850 on SourceForge spells out the

   873 		   hopelessness of trying anything else (fseek and ftell

   874 		   don't work predictably x-platform for text-mode files).

   875 		*/

   876 		int ispyc = 0;

   877 		if (ftell(fp) == 0) {

   878 			if (fread(buf, 1, 2, fp) == 2 &&

   879 			    ((unsigned int)buf[1]<<8 | buf[0]) == halfmagic)

   880 				ispyc = 1;

   881 			rewind(fp);

   882 		}

   883 		return ispyc;

   884 	}

   885 	return 0;

   886 }

   887 

   888 int

   889 PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit,

   890 			PyCompilerFlags *flags)

   891 {

   892 	PyObject *m, *d, *v;

   893 	const char *ext;

   894 	int set_file_name = 0, ret;

   895 

   896 	m = PyImport_AddModule("__main__");

   897 	if (m == NULL)

   898 		return -1;

   899 	d = PyModule_GetDict(m);

   900 	if (PyDict_GetItemString(d, "__file__") == NULL) {

   901 		PyObject *f = PyString_FromString(filename);

   902 		if (f == NULL)

   903 			return -1;

   904 		if (PyDict_SetItemString(d, "__file__", f) < 0) {

   905 			Py_DECREF(f);

   906 			return -1;

   907 		}

   908 		set_file_name = 1;

   909 		Py_DECREF(f);

   910 	}

   911 	ext = filename + strlen(filename) - 4;

   912 	if (maybe_pyc_file(fp, filename, ext, closeit)) {

   913 		/* Try to run a pyc file. First, re-open in binary */

   914 		if (closeit)

   915 			fclose(fp);

   916 		if ((fp = fopen(filename, "rb")) == NULL) {

   917 			fprintf(stderr, "python: Can't reopen .pyc file\n");

   918 			ret = -1;

   919 			goto done;

   920 		}

   921 		/* Turn on optimization if a .pyo file is given */

   922 		if (strcmp(ext, ".pyo") == 0)

   923 			Py_OptimizeFlag = 1;

   924 		v = run_pyc_file(fp, filename, d, d, flags);

   925 	} else {

   926 		v = PyRun_FileExFlags(fp, filename, Py_file_input, d, d,

   927 				      closeit, flags);

   928 	}

   929 	if (v == NULL) {

   930 		PyErr_Print();

   931 		ret = -1;

   932 		goto done;

   933 	}

   934 	Py_DECREF(v);

   935 	if (Py_FlushLine())

   936 		PyErr_Clear();

   937 	ret = 0;

   938   done:

   939 	if (set_file_name && PyDict_DelItemString(d, "__file__"))

   940 		PyErr_Clear();

   941 	return ret;

   942 }

   943 

   944 int

   945 PyRun_SimpleStringFlags(const char *command, PyCompilerFlags *flags)

   946 {

   947 	PyObject *m, *d, *v;

   948 	m = PyImport_AddModule("__main__");

   949 	if (m == NULL)

   950 		return -1;

   951 	d = PyModule_GetDict(m);

   952 	v = PyRun_StringFlags(command, Py_file_input, d, d, flags);

   953 	if (v == NULL) {

   954 		PyErr_Print();

   955 		return -1;

   956 	}

   957 	Py_DECREF(v);

   958 	if (Py_FlushLine())

   959 		PyErr_Clear();

   960 	return 0;

   961 }

   962 

   963 static int

   964 parse_syntax_error(PyObject *err, PyObject **message, const char **filename,

   965 		   int *lineno, int *offset, const char **text)

   966 {

   967 	long hold;

   968 	PyObject *v;

   969 

   970 	/* old style errors */

   971 	if (PyTuple_Check(err))

   972 		return PyArg_ParseTuple(err, "O(ziiz)", message, filename,

   973 					lineno, offset, text);

   974 

   975 	/* new style errors.  `err' is an instance */

   976 

   977 	if (! (v = PyObject_GetAttrString(err, "msg")))

   978 		goto finally;

   979 	*message = v;

   980 

   981 	if (!(v = PyObject_GetAttrString(err, "filename")))

   982 		goto finally;

   983 	if (v == Py_None)

   984 		*filename = NULL;

   985 	else if (! (*filename = PyString_AsString(v)))

   986 		goto finally;

   987 

   988 	Py_DECREF(v);

   989 	if (!(v = PyObject_GetAttrString(err, "lineno")))

   990 		goto finally;

   991 	hold = PyInt_AsLong(v);

   992 	Py_DECREF(v);

   993 	v = NULL;

   994 	if (hold < 0 && PyErr_Occurred())

   995 		goto finally;

   996 	*lineno = (int)hold;

   997 

   998 	if (!(v = PyObject_GetAttrString(err, "offset")))

   999 		goto finally;

  1000 	if (v == Py_None) {

  1001 		*offset = -1;

  1002 		Py_DECREF(v);

  1003 		v = NULL;

  1004 	} else {

  1005 		hold = PyInt_AsLong(v);

  1006 		Py_DECREF(v);

  1007 		v = NULL;

  1008 		if (hold < 0 && PyErr_Occurred())

  1009 			goto finally;

  1010 		*offset = (int)hold;

  1011 	}

  1012 

  1013 	if (!(v = PyObject_GetAttrString(err, "text")))

  1014 		goto finally;

  1015 	if (v == Py_None)

  1016 		*text = NULL;

  1017 	else if (! (*text = PyString_AsString(v)))

  1018 		goto finally;

  1019 	Py_DECREF(v);

  1020 	return 1;

  1021 

  1022 finally:

  1023 	Py_XDECREF(v);

  1024 	return 0;

  1025 }

  1026 

  1027 void

  1028 PyErr_Print(void)

  1029 {

  1030 	PyErr_PrintEx(1);

  1031 }

  1032 

  1033 static void

  1034 print_error_text(PyObject *f, int offset, const char *text)

  1035 {

  1036 	char *nl;

  1037 	if (offset >= 0) {

  1038 		if (offset > 0 && offset == (int)strlen(text))

  1039 			offset--;

  1040 		for (;;) {

  1041 			nl = strchr(text, '\n');

  1042 			if (nl == NULL || nl-text >= offset)

  1043 				break;

  1044 			offset -= (int)(nl+1-text);

  1045 			text = nl+1;

  1046 		}

  1047 		while (*text == ' ' || *text == '\t') {

  1048 			text++;

  1049 			offset--;

  1050 		}

  1051 	}

  1052 	PyFile_WriteString("    ", f);

  1053 	PyFile_WriteString(text, f);

  1054 	if (*text == '\0' || text[strlen(text)-1] != '\n')

  1055 		PyFile_WriteString("\n", f);

  1056 	if (offset == -1)

  1057 		return;

  1058 	PyFile_WriteString("    ", f);

  1059 	offset--;

  1060 	while (offset > 0) {

  1061 		PyFile_WriteString(" ", f);

  1062 		offset--;

  1063 	}

  1064 	PyFile_WriteString("^\n", f);

  1065 }

  1066 

  1067 static void

  1068 handle_system_exit(void)

  1069 {

  1070 	PyObject *exception, *value, *tb;

  1071 	int exitcode = 0;

  1072 

  1073 	if (Py_InspectFlag)

  1074 		/* Don't exit if -i flag was given. This flag is set to 0

  1075 		 * when entering interactive mode for inspecting. */

  1076 		return;

  1077 

  1078 	PyErr_Fetch(&exception, &value, &tb);

  1079 	if (Py_FlushLine())

  1080 		PyErr_Clear();

  1081 	fflush(stdout);

  1082 	if (value == NULL || value == Py_None)

  1083 		goto done;

  1084 	if (PyExceptionInstance_Check(value)) {

  1085 		/* The error code should be in the `code' attribute. */

  1086 		PyObject *code = PyObject_GetAttrString(value, "code");

  1087 		if (code) {

  1088 			Py_DECREF(value);

  1089 			value = code;

  1090 			if (value == Py_None)

  1091 				goto done;

  1092 		}

  1093 		/* If we failed to dig out the 'code' attribute,

  1094 		   just let the else clause below print the error. */

  1095 	}

  1096 	if (PyInt_Check(value))

  1097 		exitcode = (int)PyInt_AsLong(value);

  1098 	else {

  1099 		PyObject_Print(value, stderr, Py_PRINT_RAW);

  1100 		PySys_WriteStderr("\n");

  1101 		exitcode = 1;

  1102 	}

  1103  done:

  1104 	/* Restore and clear the exception info, in order to properly decref

  1105 	 * the exception, value, and traceback.	 If we just exit instead,

  1106 	 * these leak, which confuses PYTHONDUMPREFS output, and may prevent

  1107 	 * some finalizers from running.

  1108 	 */

  1109 	PyErr_Restore(exception, value, tb);

  1110 	PyErr_Clear();

  1111 	Py_Exit(exitcode);

  1112 	/* NOTREACHED */

  1113 }

  1114 

  1115 void

  1116 PyErr_PrintEx(int set_sys_last_vars)

  1117 {

  1118 	PyObject *exception, *v, *tb, *hook;

  1119 

  1120 	if (PyErr_ExceptionMatches(PyExc_SystemExit)) {

  1121 		handle_system_exit();

  1122 	}

  1123 	PyErr_Fetch(&exception, &v, &tb);

  1124 	if (exception == NULL)

  1125 		return;

  1126 	PyErr_NormalizeException(&exception, &v, &tb);

  1127 	if (exception == NULL)

  1128 		return;

  1129 	/* Now we know v != NULL too */

  1130 	if (set_sys_last_vars) {

  1131 		PySys_SetObject("last_type", exception);

  1132 		PySys_SetObject("last_value", v);

  1133 		PySys_SetObject("last_traceback", tb);

  1134 	}

  1135 	hook = PySys_GetObject("excepthook");