blob: 8e1cd6236c5e622f993c2adbf4848ca1af942e01 [file] [log] [blame]
Guido van Rossum1984f1e1992-08-04 12:41:02 +00001
2/* Python interpreter top-level routines, including init/exit */
3
Guido van Rossum82598051997-03-05 00:20:32 +00004#include "Python.h"
Guido van Rossum1984f1e1992-08-04 12:41:02 +00005
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00006#include "Python-ast.h"
Kristján Valur Jónsson67387fb2007-04-25 00:17:39 +00007#undef Yield /* undefine macro conflicting with winbase.h */
Guido van Rossum1984f1e1992-08-04 12:41:02 +00008#include "grammar.h"
9#include "node.h"
Fred Drake85f36392000-07-11 17:53:00 +000010#include "token.h"
Guido van Rossum1984f1e1992-08-04 12:41:02 +000011#include "parsetok.h"
Guido van Rossum1984f1e1992-08-04 12:41:02 +000012#include "errcode.h"
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000013#include "code.h"
Guido van Rossum1984f1e1992-08-04 12:41:02 +000014#include "compile.h"
Jeremy Hylton4b38da62001-02-02 18:19:15 +000015#include "symtable.h"
Neal Norwitzadb69fc2005-12-17 20:54:49 +000016#include "pyarena.h"
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000017#include "ast.h"
Guido van Rossumff4949e1992-08-05 19:58:53 +000018#include "eval.h"
Guido van Rossumfdef2711994-09-14 13:31:04 +000019#include "marshal.h"
Antoine Pitrouefb60c02009-10-20 21:29:37 +000020#include "abstract.h"
Guido van Rossum1984f1e1992-08-04 12:41:02 +000021
Martin v. Löwis0e8bd7e2006-06-10 12:23:46 +000022#ifdef HAVE_SIGNAL_H
Guido van Rossuma9e7dc11992-10-18 18:53:57 +000023#include <signal.h>
Martin v. Löwis0e8bd7e2006-06-10 12:23:46 +000024#endif
Guido van Rossuma9e7dc11992-10-18 18:53:57 +000025
Benjamin Peterson796798b2009-01-02 20:47:27 +000026#ifdef MS_WINDOWS
Martin v. Löwis5344c992009-01-02 20:32:55 +000027#include "malloc.h" /* for alloca */
Benjamin Peterson796798b2009-01-02 20:47:27 +000028#endif
Martin v. Löwis5344c992009-01-02 20:32:55 +000029
Martin v. Löwis73d538b2003-03-05 15:13:47 +000030#ifdef HAVE_LANGINFO_H
31#include <locale.h>
32#include <langinfo.h>
33#endif
34
Martin v. Löwis6238d2b2002-06-30 15:26:10 +000035#ifdef MS_WINDOWS
Guido van Rossuma44823b1995-03-14 15:01:17 +000036#undef BYTE
37#include "windows.h"
38#endif
39
Neal Norwitz4281cef2006-03-04 19:58:13 +000040#ifndef Py_REF_DEBUG
Tim Peters62e97f02006-03-28 21:44:32 +000041#define PRINT_TOTAL_REFS()
Neal Norwitz4281cef2006-03-04 19:58:13 +000042#else /* Py_REF_DEBUG */
Antoine Pitrouc83ea132010-05-09 14:46:46 +000043#define PRINT_TOTAL_REFS() fprintf(stderr, \
44 "[%" PY_FORMAT_SIZE_T "d refs]\n", \
45 _Py_GetRefTotal())
Neal Norwitz4281cef2006-03-04 19:58:13 +000046#endif
47
Anthony Baxterac6bd462006-04-13 02:06:09 +000048#ifdef __cplusplus
49extern "C" {
50#endif
51
Thomas Woutersf70ef4f2000-07-22 18:47:25 +000052extern char *Py_GetPath(void);
Guido van Rossum1984f1e1992-08-04 12:41:02 +000053
Guido van Rossum82598051997-03-05 00:20:32 +000054extern grammar _PyParser_Grammar; /* From graminit.c */
Guido van Rossum1984f1e1992-08-04 12:41:02 +000055
Guido van Rossumb73cc041993-11-01 16:28:59 +000056/* Forward */
Tim Petersdbd9ba62000-07-09 03:09:57 +000057static void initmain(void);
58static void initsite(void);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000059static PyObject *run_mod(mod_ty, const char *, PyObject *, PyObject *,
Antoine Pitrouc83ea132010-05-09 14:46:46 +000060 PyCompilerFlags *, PyArena *);
Martin v. Löwis95292d62002-12-11 14:04:59 +000061static PyObject *run_pyc_file(FILE *, const char *, PyObject *, PyObject *,
Antoine Pitrouc83ea132010-05-09 14:46:46 +000062 PyCompilerFlags *);
Tim Petersdbd9ba62000-07-09 03:09:57 +000063static void err_input(perrdetail *);
64static void initsigs(void);
Antoine Pitrouefb60c02009-10-20 21:29:37 +000065static void wait_for_thread_shutdown(void);
Tim Petersdbd9ba62000-07-09 03:09:57 +000066static void call_sys_exitfunc(void);
67static void call_ll_exitfuncs(void);
Thomas Woutersf70ef4f2000-07-22 18:47:25 +000068extern void _PyUnicode_Init(void);
69extern void _PyUnicode_Fini(void);
Barry Warsaw1e13eb02012-02-20 20:42:21 -050070extern void _PyRandom_Init(void);
Guido van Rossumc94044c2000-03-10 23:03:54 +000071
Mark Hammond8d98d2c2003-04-19 15:41:53 +000072#ifdef WITH_THREAD
73extern void _PyGILState_Init(PyInterpreterState *, PyThreadState *);
74extern void _PyGILState_Fini(void);
75#endif /* WITH_THREAD */
76
Guido van Rossum82598051997-03-05 00:20:32 +000077int Py_DebugFlag; /* Needed by parser.c */
78int Py_VerboseFlag; /* Needed by import.c */
Guido van Rossum7433b121997-02-14 19:45:36 +000079int Py_InteractiveFlag; /* Needed by Py_FdIsInteractive() below */
Georg Brandl11041f02011-05-15 08:50:32 +020080int Py_InspectFlag; /* Needed to determine whether to exit at SystemExit */
Guido van Rossumdcc0c131997-08-29 22:32:42 +000081int Py_NoSiteFlag; /* Suppress 'import site' */
Christian Heimes1a6387e2008-03-26 12:49:49 +000082int Py_BytesWarningFlag; /* Warn on str(bytes) and str(buffer) */
Georg Brandl2da0fce2008-01-07 17:09:35 +000083int Py_DontWriteBytecodeFlag; /* Suppress writing bytecode files (*.py[co]) */
Barry Warsaw3ce09642000-05-02 19:18:59 +000084int Py_UseClassExceptionsFlag = 1; /* Needed by bltinmodule.c: deprecated */
Guido van Rossuma61691e1998-02-06 22:27:24 +000085int Py_FrozenFlag; /* Needed by getpath.c */
Guido van Rossumb16d1972000-05-01 17:55:15 +000086int Py_UnicodeFlag = 0; /* Needed by compile.c */
Neil Schemenauer7d4bb9f2001-07-23 16:30:27 +000087int Py_IgnoreEnvironmentFlag; /* e.g. PYTHONPATH, PYTHONHOME */
Tim Peters3caca232001-12-06 06:23:26 +000088/* _XXX Py_QnewFlag should go away in 2.3. It's true iff -Qnew is passed,
89 on the command line, and is used in 2.2 by ceval.c to make all "/" divisions
90 true divisions (which they will be in 2.3). */
91int _Py_QnewFlag = 0;
Christian Heimesaf748c32008-05-06 22:41:46 +000092int Py_NoUserSiteDirectory = 0; /* for -s and site.py */
Barry Warsaw1e13eb02012-02-20 20:42:21 -050093int Py_HashRandomizationFlag = 0; /* for -R and PYTHONHASHSEED */
Guido van Rossum1984f1e1992-08-04 12:41:02 +000094
Brett Cannone9746892008-04-12 23:44:07 +000095/* PyModule_GetWarningsModule is no longer necessary as of 2.6
96since _warnings is builtin. This API should not be used. */
97PyObject *
98PyModule_GetWarningsModule(void)
Mark Hammondedd07732003-07-15 23:03:55 +000099{
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000100 return PyImport_ImportModule("warnings");
Mark Hammondedd07732003-07-15 23:03:55 +0000101}
Mark Hammonda43fd0c2003-02-19 00:33:33 +0000102
Guido van Rossum25ce5661997-08-02 03:10:38 +0000103static int initialized = 0;
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000104
Thomas Wouters7e474022000-07-16 12:04:32 +0000105/* API to access the initialized flag -- useful for esoteric use */
Guido van Rossume3c0d5e1997-08-22 04:20:13 +0000106
107int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000108Py_IsInitialized(void)
Guido van Rossume3c0d5e1997-08-22 04:20:13 +0000109{
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000110 return initialized;
Guido van Rossume3c0d5e1997-08-22 04:20:13 +0000111}
112
Guido van Rossum25ce5661997-08-02 03:10:38 +0000113/* Global initializations. Can be undone by Py_Finalize(). Don't
114 call this twice without an intervening Py_Finalize() call. When
115 initializations fail, a fatal error is issued and the function does
116 not return. On return, the first thread and interpreter state have
117 been created.
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000118
Guido van Rossum25ce5661997-08-02 03:10:38 +0000119 Locking: you must hold the interpreter lock while calling this.
120 (If the lock has not yet been initialized, that's equivalent to
121 having the lock, but you cannot use multiple threads.)
Guido van Rossuma9e7dc11992-10-18 18:53:57 +0000122
Guido van Rossum25ce5661997-08-02 03:10:38 +0000123*/
Guido van Rossuma027efa1997-05-05 20:56:21 +0000124
Guido van Rossum9abaf4d2001-10-12 22:17:56 +0000125static int
126add_flag(int flag, const char *envs)
127{
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000128 int env = atoi(envs);
129 if (flag < env)
130 flag = env;
131 if (flag < 1)
132 flag = 1;
133 return flag;
Guido van Rossum9abaf4d2001-10-12 22:17:56 +0000134}
135
Guido van Rossuma027efa1997-05-05 20:56:21 +0000136void
Martin v. Löwis336e85f2004-08-19 11:31:58 +0000137Py_InitializeEx(int install_sigs)
Guido van Rossuma027efa1997-05-05 20:56:21 +0000138{
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000139 PyInterpreterState *interp;
140 PyThreadState *tstate;
141 PyObject *bimod, *sysmod;
142 char *p;
143 char *icodeset = NULL; /* On Windows, input codeset may theoretically
144 differ from output codeset. */
145 char *codeset = NULL;
146 char *errors = NULL;
147 int free_codeset = 0;
148 int overridden = 0;
149 PyObject *sys_stream, *sys_isatty;
Martin v. Löwisa2c17c52003-08-09 09:47:11 +0000150#if defined(Py_USING_UNICODE) && defined(HAVE_LANGINFO_H) && defined(CODESET)
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000151 char *saved_locale, *loc_codeset;
Martin v. Löwisa2c17c52003-08-09 09:47:11 +0000152#endif
Martin v. Löwis99815892008-06-01 07:20:46 +0000153#ifdef MS_WINDOWS
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000154 char ibuf[128];
155 char buf[128];
Martin v. Löwis99815892008-06-01 07:20:46 +0000156#endif
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000157 extern void _Py_ReadyTypes(void);
Guido van Rossumad6dfda1997-07-19 19:17:22 +0000158
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000159 if (initialized)
160 return;
161 initialized = 1;
Tim Petersd08e3822003-04-17 15:24:21 +0000162
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000163 if ((p = Py_GETENV("PYTHONDEBUG")) && *p != '\0')
164 Py_DebugFlag = add_flag(Py_DebugFlag, p);
165 if ((p = Py_GETENV("PYTHONVERBOSE")) && *p != '\0')
166 Py_VerboseFlag = add_flag(Py_VerboseFlag, p);
167 if ((p = Py_GETENV("PYTHONOPTIMIZE")) && *p != '\0')
168 Py_OptimizeFlag = add_flag(Py_OptimizeFlag, p);
169 if ((p = Py_GETENV("PYTHONDONTWRITEBYTECODE")) && *p != '\0')
170 Py_DontWriteBytecodeFlag = add_flag(Py_DontWriteBytecodeFlag, p);
Barry Warsaw1e13eb02012-02-20 20:42:21 -0500171 /* The variable is only tested for existence here; _PyRandom_Init will
172 check its value further. */
173 if ((p = Py_GETENV("PYTHONHASHSEED")) && *p != '\0')
174 Py_HashRandomizationFlag = add_flag(Py_HashRandomizationFlag, p);
175
176 _PyRandom_Init();
Guido van Rossumad6dfda1997-07-19 19:17:22 +0000177
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000178 interp = PyInterpreterState_New();
179 if (interp == NULL)
180 Py_FatalError("Py_Initialize: can't make first interpreter");
Guido van Rossumad6dfda1997-07-19 19:17:22 +0000181
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000182 tstate = PyThreadState_New(interp);
183 if (tstate == NULL)
184 Py_FatalError("Py_Initialize: can't make first thread");
185 (void) PyThreadState_Swap(tstate);
Guido van Rossuma027efa1997-05-05 20:56:21 +0000186
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000187 _Py_ReadyTypes();
Guido van Rossum528b7eb2001-08-07 17:24:28 +0000188
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000189 if (!_PyFrame_Init())
190 Py_FatalError("Py_Initialize: can't init frames");
Neal Norwitzc91ed402002-12-30 22:29:22 +0000191
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000192 if (!_PyInt_Init())
193 Py_FatalError("Py_Initialize: can't init ints");
Neal Norwitzc91ed402002-12-30 22:29:22 +0000194
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000195 if (!_PyLong_Init())
196 Py_FatalError("Py_Initialize: can't init longs");
Mark Dickinsonefc82f72009-03-20 15:51:55 +0000197
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000198 if (!PyByteArray_Init())
199 Py_FatalError("Py_Initialize: can't init bytearray");
Christian Heimes1a6387e2008-03-26 12:49:49 +0000200
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000201 _PyFloat_Init();
Michael W. Hudsonba283e22005-05-27 15:23:20 +0000202
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000203 interp->modules = PyDict_New();
204 if (interp->modules == NULL)
205 Py_FatalError("Py_Initialize: can't make modules dictionary");
206 interp->modules_reloading = PyDict_New();
207 if (interp->modules_reloading == NULL)
208 Py_FatalError("Py_Initialize: can't make modules_reloading dictionary");
Guido van Rossuma027efa1997-05-05 20:56:21 +0000209
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000210#ifdef Py_USING_UNICODE
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000211 /* Init Unicode implementation; relies on the codec registry */
212 _PyUnicode_Init();
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000213#endif
Guido van Rossumc94044c2000-03-10 23:03:54 +0000214
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000215 bimod = _PyBuiltin_Init();
216 if (bimod == NULL)
217 Py_FatalError("Py_Initialize: can't initialize __builtin__");
218 interp->builtins = PyModule_GetDict(bimod);
219 if (interp->builtins == NULL)
220 Py_FatalError("Py_Initialize: can't initialize builtins dict");
221 Py_INCREF(interp->builtins);
Guido van Rossum25ce5661997-08-02 03:10:38 +0000222
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000223 sysmod = _PySys_Init();
224 if (sysmod == NULL)
225 Py_FatalError("Py_Initialize: can't initialize sys");
226 interp->sysdict = PyModule_GetDict(sysmod);
227 if (interp->sysdict == NULL)
228 Py_FatalError("Py_Initialize: can't initialize sys dict");
229 Py_INCREF(interp->sysdict);
230 _PyImport_FixupExtension("sys", "sys");
231 PySys_SetPath(Py_GetPath());
232 PyDict_SetItemString(interp->sysdict, "modules",
233 interp->modules);
Guido van Rossum25ce5661997-08-02 03:10:38 +0000234
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000235 _PyImport_Init();
Guido van Rossum7c85ab81999-07-08 17:26:56 +0000236
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000237 /* initialize builtin exceptions */
238 _PyExc_Init();
239 _PyImport_FixupExtension("exceptions", "exceptions");
Barry Warsawf242aa02000-05-25 23:09:49 +0000240
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000241 /* phase 2 of builtins */
242 _PyImport_FixupExtension("__builtin__", "__builtin__");
Barry Warsaw035574d1997-08-29 22:07:17 +0000243
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000244 _PyImportHooks_Init();
Just van Rossum52e14d62002-12-30 22:08:05 +0000245
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000246 if (install_sigs)
247 initsigs(); /* Signal handling stuff, including initintr() */
Brett Cannonc33e82d2010-05-05 20:38:52 +0000248
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000249 /* Initialize warnings. */
250 _PyWarnings_Init();
251 if (PySys_HasWarnOptions()) {
252 PyObject *warnings_module = PyImport_ImportModule("warnings");
253 if (!warnings_module)
254 PyErr_Clear();
255 Py_XDECREF(warnings_module);
256 }
Guido van Rossum25ce5661997-08-02 03:10:38 +0000257
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000258 initmain(); /* Module __main__ */
Just van Rossum5bfba3a2003-02-25 20:25:12 +0000259
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000260 /* auto-thread-state API, if available */
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000261#ifdef WITH_THREAD
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000262 _PyGILState_Init(interp, tstate);
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000263#endif /* WITH_THREAD */
264
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000265 if (!Py_NoSiteFlag)
266 initsite(); /* Module site */
Victor Stinner66644262010-03-10 22:30:19 +0000267
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000268 if ((p = Py_GETENV("PYTHONIOENCODING")) && *p != '\0') {
269 p = icodeset = codeset = strdup(p);
270 free_codeset = 1;
271 errors = strchr(p, ':');
272 if (errors) {
273 *errors = '\0';
274 errors++;
275 }
276 overridden = 1;
277 }
Martin v. Löwis99815892008-06-01 07:20:46 +0000278
Martin v. Löwis73d538b2003-03-05 15:13:47 +0000279#if defined(Py_USING_UNICODE) && defined(HAVE_LANGINFO_H) && defined(CODESET)
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000280 /* On Unix, set the file system encoding according to the
281 user's preference, if the CODESET names a well-known
282 Python codec, and Py_FileSystemDefaultEncoding isn't
283 initialized by other means. Also set the encoding of
284 stdin and stdout if these are terminals, unless overridden. */
Martin v. Löwisa2c17c52003-08-09 09:47:11 +0000285
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000286 if (!overridden || !Py_FileSystemDefaultEncoding) {
287 saved_locale = strdup(setlocale(LC_CTYPE, NULL));
288 setlocale(LC_CTYPE, "");
289 loc_codeset = nl_langinfo(CODESET);
290 if (loc_codeset && *loc_codeset) {
291 PyObject *enc = PyCodec_Encoder(loc_codeset);
292 if (enc) {
293 loc_codeset = strdup(loc_codeset);
294 Py_DECREF(enc);
295 } else {
296 if (PyErr_ExceptionMatches(PyExc_LookupError)) {
297 PyErr_Clear();
298 loc_codeset = NULL;
299 } else {
300 PyErr_Print();
301 exit(1);
302 }
303 }
304 } else
305 loc_codeset = NULL;
306 setlocale(LC_CTYPE, saved_locale);
307 free(saved_locale);
Martin v. Löwis99815892008-06-01 07:20:46 +0000308
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000309 if (!overridden) {
310 codeset = icodeset = loc_codeset;
311 free_codeset = 1;
312 }
Martin v. Löwis99815892008-06-01 07:20:46 +0000313
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000314 /* Initialize Py_FileSystemDefaultEncoding from
315 locale even if PYTHONIOENCODING is set. */
316 if (!Py_FileSystemDefaultEncoding) {
317 Py_FileSystemDefaultEncoding = loc_codeset;
318 if (!overridden)
319 free_codeset = 0;
320 }
321 }
Martin v. Löwis99815892008-06-01 07:20:46 +0000322#endif
323
324#ifdef MS_WINDOWS
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000325 if (!overridden) {
326 icodeset = ibuf;
327 codeset = buf;
328 sprintf(ibuf, "cp%d", GetConsoleCP());
329 sprintf(buf, "cp%d", GetConsoleOutputCP());
330 }
Martin v. Löwis99815892008-06-01 07:20:46 +0000331#endif
Martin v. Löwisa2c17c52003-08-09 09:47:11 +0000332
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000333 if (codeset) {
334 sys_stream = PySys_GetObject("stdin");
335 sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");
336 if (!sys_isatty)
337 PyErr_Clear();
338 if ((overridden ||
339 (sys_isatty && PyObject_IsTrue(sys_isatty))) &&
340 PyFile_Check(sys_stream)) {
341 if (!PyFile_SetEncodingAndErrors(sys_stream, icodeset, errors))
342 Py_FatalError("Cannot set codeset of stdin");
343 }
344 Py_XDECREF(sys_isatty);
Martin v. Löwisa2c17c52003-08-09 09:47:11 +0000345
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000346 sys_stream = PySys_GetObject("stdout");
347 sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");
348 if (!sys_isatty)
349 PyErr_Clear();
350 if ((overridden ||
351 (sys_isatty && PyObject_IsTrue(sys_isatty))) &&
352 PyFile_Check(sys_stream)) {
353 if (!PyFile_SetEncodingAndErrors(sys_stream, codeset, errors))
354 Py_FatalError("Cannot set codeset of stdout");
355 }
356 Py_XDECREF(sys_isatty);
Martin v. Löwisa2c17c52003-08-09 09:47:11 +0000357
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000358 sys_stream = PySys_GetObject("stderr");
359 sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");
360 if (!sys_isatty)
361 PyErr_Clear();
362 if((overridden ||
363 (sys_isatty && PyObject_IsTrue(sys_isatty))) &&
364 PyFile_Check(sys_stream)) {
365 if (!PyFile_SetEncodingAndErrors(sys_stream, codeset, errors))
366 Py_FatalError("Cannot set codeset of stderr");
367 }
368 Py_XDECREF(sys_isatty);
Martin v. Löwisea62d252006-04-03 10:56:49 +0000369
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000370 if (free_codeset)
371 free(codeset);
372 }
Guido van Rossum25ce5661997-08-02 03:10:38 +0000373}
374
Martin v. Löwis336e85f2004-08-19 11:31:58 +0000375void
376Py_Initialize(void)
377{
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000378 Py_InitializeEx(1);
Martin v. Löwis336e85f2004-08-19 11:31:58 +0000379}
380
381
Guido van Rossum2edcf0d1998-12-15 16:12:00 +0000382#ifdef COUNT_ALLOCS
Martin v. Löwis45294a92006-04-18 06:24:08 +0000383extern void dump_counts(FILE*);
Guido van Rossum2edcf0d1998-12-15 16:12:00 +0000384#endif
385
Guido van Rossum25ce5661997-08-02 03:10:38 +0000386/* Undo the effect of Py_Initialize().
387
388 Beware: if multiple interpreter and/or thread states exist, these
389 are not wiped out; only the current thread and interpreter state
390 are deleted. But since everything else is deleted, those other
391 interpreter and thread states should no longer be used.
392
393 (XXX We should do better, e.g. wipe out all interpreters and
394 threads.)
395
396 Locking: as above.
397
398*/
399
400void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000401Py_Finalize(void)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000402{
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000403 PyInterpreterState *interp;
404 PyThreadState *tstate;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000405
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000406 if (!initialized)
407 return;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000408
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000409 wait_for_thread_shutdown();
Antoine Pitrouefb60c02009-10-20 21:29:37 +0000410
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000411 /* The interpreter is still entirely intact at this point, and the
412 * exit funcs may be relying on that. In particular, if some thread
413 * or exit func is still waiting to do an import, the import machinery
414 * expects Py_IsInitialized() to return true. So don't say the
415 * interpreter is uninitialized until after the exit funcs have run.
416 * Note that Threading.py uses an exit func to do a join on all the
417 * threads created thru it, so this also protects pending imports in
418 * the threads created via Threading.
419 */
420 call_sys_exitfunc();
421 initialized = 0;
Guido van Rossum4cc462e1998-01-19 22:00:38 +0000422
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000423 /* Get current thread state and interpreter pointer */
424 tstate = PyThreadState_GET();
425 interp = tstate->interp;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000426
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000427 /* Disable signal handling */
428 PyOS_FiniInterrupts();
Guido van Rossum3a44e1b1997-11-03 21:58:47 +0000429
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000430 /* Clear type lookup cache */
431 PyType_ClearCache();
Christian Heimes908caac2008-01-27 23:34:59 +0000432
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000433 /* Collect garbage. This may call finalizers; it's nice to call these
434 * before all modules are destroyed.
435 * XXX If a __del__ or weakref callback is triggered here, and tries to
436 * XXX import a module, bad things can happen, because Python no
437 * XXX longer believes it's initialized.
438 * XXX Fatal Python error: Interpreter not initialized (version mismatch?)
439 * XXX is easy to provoke that way. I've also seen, e.g.,
440 * XXX Exception exceptions.ImportError: 'No module named sha'
441 * XXX in <function callback at 0x008F5718> ignored
442 * XXX but I'm unclear on exactly how that one happens. In any case,
443 * XXX I haven't seen a real-life report of either of these.
444 */
445 PyGC_Collect();
Martin v. Löwis45294a92006-04-18 06:24:08 +0000446#ifdef COUNT_ALLOCS
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000447 /* With COUNT_ALLOCS, it helps to run GC multiple times:
448 each collection might release some types from the type
449 list, so they become garbage. */
450 while (PyGC_Collect() > 0)
451 /* nothing */;
Martin v. Löwis45294a92006-04-18 06:24:08 +0000452#endif
Guido van Rossume13ddc92003-04-17 17:29:22 +0000453
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000454 /* Destroy all modules */
455 PyImport_Cleanup();
Guido van Rossum3a44e1b1997-11-03 21:58:47 +0000456
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000457 /* Collect final garbage. This disposes of cycles created by
458 * new-style class definitions, for example.
459 * XXX This is disabled because it caused too many problems. If
460 * XXX a __del__ or weakref callback triggers here, Python code has
461 * XXX a hard time running, because even the sys module has been
462 * XXX cleared out (sys.stdout is gone, sys.excepthook is gone, etc).
463 * XXX One symptom is a sequence of information-free messages
464 * XXX coming from threads (if a __del__ or callback is invoked,
465 * XXX other threads can execute too, and any exception they encounter
466 * XXX triggers a comedy of errors as subsystem after subsystem
467 * XXX fails to find what it *expects* to find in sys to help report
468 * XXX the exception and consequent unexpected failures). I've also
469 * XXX seen segfaults then, after adding print statements to the
470 * XXX Python code getting called.
471 */
Tim Peters1d7323e2003-12-01 21:35:27 +0000472#if 0
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000473 PyGC_Collect();
Tim Peters1d7323e2003-12-01 21:35:27 +0000474#endif
Guido van Rossume13ddc92003-04-17 17:29:22 +0000475
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000476 /* Destroy the database used by _PyImport_{Fixup,Find}Extension */
477 _PyImport_Fini();
Guido van Rossum1707aad1997-12-08 23:43:45 +0000478
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000479 /* Debugging stuff */
Guido van Rossum1707aad1997-12-08 23:43:45 +0000480#ifdef COUNT_ALLOCS
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000481 dump_counts(stdout);
Guido van Rossum1707aad1997-12-08 23:43:45 +0000482#endif
483
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000484 PRINT_TOTAL_REFS();
Guido van Rossum1707aad1997-12-08 23:43:45 +0000485
Tim Peters9cf25ce2003-04-17 15:21:01 +0000486#ifdef Py_TRACE_REFS
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000487 /* Display all objects still alive -- this can invoke arbitrary
488 * __repr__ overrides, so requires a mostly-intact interpreter.
489 * Alas, a lot of stuff may still be alive now that will be cleaned
490 * up later.
491 */
492 if (Py_GETENV("PYTHONDUMPREFS"))
493 _Py_PrintReferences(stderr);
Tim Peters9cf25ce2003-04-17 15:21:01 +0000494#endif /* Py_TRACE_REFS */
495
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000496 /* Clear interpreter state */
497 PyInterpreterState_Clear(interp);
Guido van Rossumd922fa42003-04-15 14:10:09 +0000498
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000499 /* Now we decref the exception classes. After this point nothing
500 can raise an exception. That's okay, because each Fini() method
501 below has been checked to make sure no exceptions are ever
502 raised.
503 */
Anthony Baxter12b6f6c2005-03-29 13:36:16 +0000504
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000505 _PyExc_Fini();
Anthony Baxter12b6f6c2005-03-29 13:36:16 +0000506
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000507 /* Cleanup auto-thread-state */
Amaury Forgeot d'Arc025c3472007-11-29 23:35:25 +0000508#ifdef WITH_THREAD
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000509 _PyGILState_Fini();
Amaury Forgeot d'Arc025c3472007-11-29 23:35:25 +0000510#endif /* WITH_THREAD */
511
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000512 /* Delete current thread */
513 PyThreadState_Swap(NULL);
514 PyInterpreterState_Delete(interp);
Barry Warsawf242aa02000-05-25 23:09:49 +0000515
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000516 /* Sundry finalizers */
517 PyMethod_Fini();
518 PyFrame_Fini();
519 PyCFunction_Fini();
520 PyTuple_Fini();
521 PyList_Fini();
522 PySet_Fini();
523 PyString_Fini();
524 PyByteArray_Fini();
525 PyInt_Fini();
526 PyFloat_Fini();
527 PyDict_Fini();
Guido van Rossumcc283f51997-08-05 02:22:03 +0000528
Marc-André Lemburg95de5c12002-04-08 08:19:36 +0000529#ifdef Py_USING_UNICODE
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000530 /* Cleanup Unicode implementation */
531 _PyUnicode_Fini();
Marc-André Lemburg95de5c12002-04-08 08:19:36 +0000532#endif
533
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000534 /* XXX Still allocated:
535 - various static ad-hoc pointers to interned strings
536 - int and float free list blocks
537 - whatever various modules and libraries allocate
538 */
Guido van Rossum25ce5661997-08-02 03:10:38 +0000539
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000540 PyGrammar_RemoveAccelerators(&_PyParser_Grammar);
Guido van Rossumcc283f51997-08-05 02:22:03 +0000541
Tim Peters269b2a62003-04-17 19:52:29 +0000542#ifdef Py_TRACE_REFS
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000543 /* Display addresses (& refcnts) of all objects still alive.
544 * An address can be used to find the repr of the object, printed
545 * above by _Py_PrintReferences.
546 */
547 if (Py_GETENV("PYTHONDUMPREFS"))
548 _Py_PrintReferenceAddresses(stderr);
Tim Peters269b2a62003-04-17 19:52:29 +0000549#endif /* Py_TRACE_REFS */
Tim Peters0e871182002-04-13 08:29:14 +0000550#ifdef PYMALLOC_DEBUG
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000551 if (Py_GETENV("PYTHONMALLOCSTATS"))
552 _PyObject_DebugMallocStats();
Tim Peters0e871182002-04-13 08:29:14 +0000553#endif
554
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000555 call_ll_exitfuncs();
Guido van Rossum25ce5661997-08-02 03:10:38 +0000556}
557
558/* Create and initialize a new interpreter and thread, and return the
559 new thread. This requires that Py_Initialize() has been called
560 first.
561
562 Unsuccessful initialization yields a NULL pointer. Note that *no*
563 exception information is available even in this case -- the
564 exception information is held in the thread, and there is no
565 thread.
566
567 Locking: as above.
568
569*/
570
571PyThreadState *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000572Py_NewInterpreter(void)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000573{
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000574 PyInterpreterState *interp;
575 PyThreadState *tstate, *save_tstate;
576 PyObject *bimod, *sysmod;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000577
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000578 if (!initialized)
579 Py_FatalError("Py_NewInterpreter: call Py_Initialize first");
Guido van Rossum25ce5661997-08-02 03:10:38 +0000580
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000581 interp = PyInterpreterState_New();
582 if (interp == NULL)
583 return NULL;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000584
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000585 tstate = PyThreadState_New(interp);
586 if (tstate == NULL) {
587 PyInterpreterState_Delete(interp);
588 return NULL;
589 }
Guido van Rossum25ce5661997-08-02 03:10:38 +0000590
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000591 save_tstate = PyThreadState_Swap(tstate);
Guido van Rossum25ce5661997-08-02 03:10:38 +0000592
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000593 /* XXX The following is lax in error checking */
Guido van Rossum25ce5661997-08-02 03:10:38 +0000594
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000595 interp->modules = PyDict_New();
596 interp->modules_reloading = PyDict_New();
Guido van Rossum25ce5661997-08-02 03:10:38 +0000597
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000598 bimod = _PyImport_FindExtension("__builtin__", "__builtin__");
599 if (bimod != NULL) {
600 interp->builtins = PyModule_GetDict(bimod);
601 if (interp->builtins == NULL)
602 goto handle_error;
603 Py_INCREF(interp->builtins);
604 }
605 sysmod = _PyImport_FindExtension("sys", "sys");
606 if (bimod != NULL && sysmod != NULL) {
607 interp->sysdict = PyModule_GetDict(sysmod);
608 if (interp->sysdict == NULL)
609 goto handle_error;
610 Py_INCREF(interp->sysdict);
611 PySys_SetPath(Py_GetPath());
612 PyDict_SetItemString(interp->sysdict, "modules",
613 interp->modules);
614 _PyImportHooks_Init();
615 initmain();
616 if (!Py_NoSiteFlag)
617 initsite();
618 }
Guido van Rossum25ce5661997-08-02 03:10:38 +0000619
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000620 if (!PyErr_Occurred())
621 return tstate;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000622
Neal Norwitz0c6ae5b2006-08-21 20:16:24 +0000623handle_error:
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000624 /* Oops, it didn't work. Undo it all. */
Guido van Rossum25ce5661997-08-02 03:10:38 +0000625
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000626 PyErr_Print();
627 PyThreadState_Clear(tstate);
628 PyThreadState_Swap(save_tstate);
629 PyThreadState_Delete(tstate);
630 PyInterpreterState_Delete(interp);
Guido van Rossum25ce5661997-08-02 03:10:38 +0000631
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000632 return NULL;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000633}
634
635/* Delete an interpreter and its last thread. This requires that the
636 given thread state is current, that the thread has no remaining
637 frames, and that it is its interpreter's only remaining thread.
638 It is a fatal error to violate these constraints.
639
640 (Py_Finalize() doesn't have these constraints -- it zaps
641 everything, regardless.)
642
643 Locking: as above.
644
645*/
646
647void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000648Py_EndInterpreter(PyThreadState *tstate)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000649{
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000650 PyInterpreterState *interp = tstate->interp;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000651
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000652 if (tstate != PyThreadState_GET())
653 Py_FatalError("Py_EndInterpreter: thread is not current");
654 if (tstate->frame != NULL)
655 Py_FatalError("Py_EndInterpreter: thread still has a frame");
656 if (tstate != interp->tstate_head || tstate->next != NULL)
657 Py_FatalError("Py_EndInterpreter: not the last thread");
Guido van Rossum25ce5661997-08-02 03:10:38 +0000658
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000659 PyImport_Cleanup();
660 PyInterpreterState_Clear(interp);
661 PyThreadState_Swap(NULL);
662 PyInterpreterState_Delete(interp);
Guido van Rossumad6dfda1997-07-19 19:17:22 +0000663}
664
665static char *progname = "python";
666
667void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000668Py_SetProgramName(char *pn)
Guido van Rossumad6dfda1997-07-19 19:17:22 +0000669{
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000670 if (pn && *pn)
671 progname = pn;
Guido van Rossumad6dfda1997-07-19 19:17:22 +0000672}
673
674char *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000675Py_GetProgramName(void)
Guido van Rossumad6dfda1997-07-19 19:17:22 +0000676{
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000677 return progname;
Guido van Rossuma027efa1997-05-05 20:56:21 +0000678}
679
Guido van Rossuma61691e1998-02-06 22:27:24 +0000680static char *default_home = NULL;
681
682void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000683Py_SetPythonHome(char *home)
Guido van Rossuma61691e1998-02-06 22:27:24 +0000684{
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000685 default_home = home;
Guido van Rossuma61691e1998-02-06 22:27:24 +0000686}
687
688char *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000689Py_GetPythonHome(void)
Guido van Rossuma61691e1998-02-06 22:27:24 +0000690{
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000691 char *home = default_home;
692 if (home == NULL && !Py_IgnoreEnvironmentFlag)
693 home = Py_GETENV("PYTHONHOME");
694 return home;
Guido van Rossuma61691e1998-02-06 22:27:24 +0000695}
696
Guido van Rossum6135a871995-01-09 17:53:26 +0000697/* Create __main__ module */
698
699static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000700initmain(void)
Guido van Rossum6135a871995-01-09 17:53:26 +0000701{
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000702 PyObject *m, *d;
703 m = PyImport_AddModule("__main__");
704 if (m == NULL)
705 Py_FatalError("can't create __main__ module");
706 d = PyModule_GetDict(m);
707 if (PyDict_GetItemString(d, "__builtins__") == NULL) {
708 PyObject *bimod = PyImport_ImportModule("__builtin__");
709 if (bimod == NULL ||
710 PyDict_SetItemString(d, "__builtins__", bimod) != 0)
711 Py_FatalError("can't add __builtins__ to __main__");
712 Py_XDECREF(bimod);
713 }
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000714}
715
Guido van Rossumdcc0c131997-08-29 22:32:42 +0000716/* Import the site module (not into __main__ though) */
717
718static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000719initsite(void)
Guido van Rossumdcc0c131997-08-29 22:32:42 +0000720{
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000721 PyObject *m;
722 m = PyImport_ImportModule("site");
723 if (m == NULL) {
724 PyErr_Print();
725 Py_Finalize();
726 exit(1);
727 }
728 else {
729 Py_DECREF(m);
730 }
Guido van Rossumdcc0c131997-08-29 22:32:42 +0000731}
732
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000733/* Parse input from a file and execute it */
734
735int
Tim Peters5e9d6cf2006-05-28 10:41:29 +0000736PyRun_AnyFileExFlags(FILE *fp, const char *filename, int closeit,
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000737 PyCompilerFlags *flags)
Jeremy Hyltonbc320242001-03-22 02:47:58 +0000738{
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000739 if (filename == NULL)
740 filename = "???";
741 if (Py_FdIsInteractive(fp, filename)) {
742 int err = PyRun_InteractiveLoopFlags(fp, filename, flags);
743 if (closeit)
744 fclose(fp);
745 return err;
746 }
747 else
748 return PyRun_SimpleFileExFlags(fp, filename, closeit, flags);
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000749}
750
751int
Martin v. Löwis95292d62002-12-11 14:04:59 +0000752PyRun_InteractiveLoopFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
Jeremy Hyltonbc320242001-03-22 02:47:58 +0000753{
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000754 PyObject *v;
755 int ret;
756 PyCompilerFlags local_flags;
Jeremy Hylton9f324e92001-03-01 22:59:14 +0000757
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000758 if (flags == NULL) {
759 flags = &local_flags;
760 local_flags.cf_flags = 0;
761 }
762 v = PySys_GetObject("ps1");
763 if (v == NULL) {
764 PySys_SetObject("ps1", v = PyString_FromString(">>> "));
765 Py_XDECREF(v);
766 }
767 v = PySys_GetObject("ps2");
768 if (v == NULL) {
769 PySys_SetObject("ps2", v = PyString_FromString("... "));
770 Py_XDECREF(v);
771 }
772 for (;;) {
773 ret = PyRun_InteractiveOneFlags(fp, filename, flags);
774 PRINT_TOTAL_REFS();
775 if (ret == E_EOF)
776 return 0;
777 /*
778 if (ret == E_NOMEM)
779 return -1;
780 */
781 }
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000782}
783
Eric Smith7c478942008-03-18 23:45:49 +0000784#if 0
Neil Schemenauerc24ea082002-03-22 23:53:36 +0000785/* compute parser flags based on compiler flags */
Neil Schemenauerc24ea082002-03-22 23:53:36 +0000786#define PARSER_FLAGS(flags) \
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000787 ((flags) ? ((((flags)->cf_flags & PyCF_DONT_IMPLY_DEDENT) ? \
788 PyPARSE_DONT_IMPLY_DEDENT : 0)) : 0)
Eric Smith7c478942008-03-18 23:45:49 +0000789#endif
790#if 1
Neal Norwitzca460d92006-09-06 06:28:06 +0000791/* Keep an example of flags with future keyword support. */
792#define PARSER_FLAGS(flags) \
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000793 ((flags) ? ((((flags)->cf_flags & PyCF_DONT_IMPLY_DEDENT) ? \
794 PyPARSE_DONT_IMPLY_DEDENT : 0) \
795 | (((flags)->cf_flags & CO_FUTURE_PRINT_FUNCTION) ? \
796 PyPARSE_PRINT_IS_FUNCTION : 0) \
797 | (((flags)->cf_flags & CO_FUTURE_UNICODE_LITERALS) ? \
798 PyPARSE_UNICODE_LITERALS : 0) \
799 ) : 0)
Neal Norwitzca460d92006-09-06 06:28:06 +0000800#endif
Neil Schemenauerc24ea082002-03-22 23:53:36 +0000801
Jeremy Hylton9f324e92001-03-01 22:59:14 +0000802int
Martin v. Löwis95292d62002-12-11 14:04:59 +0000803PyRun_InteractiveOneFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
Jeremy Hylton9f324e92001-03-01 22:59:14 +0000804{
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000805 PyObject *m, *d, *v, *w;
806 mod_ty mod;
807 PyArena *arena;
808 char *ps1 = "", *ps2 = "";
809 int errcode = 0;
Tim Petersfe2127d2001-07-16 05:37:24 +0000810
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000811 v = PySys_GetObject("ps1");
812 if (v != NULL) {
813 v = PyObject_Str(v);
814 if (v == NULL)
815 PyErr_Clear();
816 else if (PyString_Check(v))
817 ps1 = PyString_AsString(v);
818 }
819 w = PySys_GetObject("ps2");
820 if (w != NULL) {
821 w = PyObject_Str(w);
822 if (w == NULL)
823 PyErr_Clear();
824 else if (PyString_Check(w))
825 ps2 = PyString_AsString(w);
826 }
827 arena = PyArena_New();
828 if (arena == NULL) {
829 Py_XDECREF(v);
830 Py_XDECREF(w);
831 return -1;
832 }
833 mod = PyParser_ASTFromFile(fp, filename,
834 Py_single_input, ps1, ps2,
835 flags, &errcode, arena);
836 Py_XDECREF(v);
837 Py_XDECREF(w);
838 if (mod == NULL) {
839 PyArena_Free(arena);
840 if (errcode == E_EOF) {
841 PyErr_Clear();
842 return E_EOF;
843 }
844 PyErr_Print();
845 return -1;
846 }
847 m = PyImport_AddModule("__main__");
848 if (m == NULL) {
849 PyArena_Free(arena);
850 return -1;
851 }
852 d = PyModule_GetDict(m);
853 v = run_mod(mod, filename, d, d, flags, arena);
854 PyArena_Free(arena);
855 if (v == NULL) {
856 PyErr_Print();
857 return -1;
858 }
859 Py_DECREF(v);
860 if (Py_FlushLine())
861 PyErr_Clear();
862 return 0;
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000863}
864
Martin v. Löwisbe4c0f52001-01-04 20:30:56 +0000865/* Check whether a file maybe a pyc file: Look at the extension,
866 the file type, and, if we may close it, at the first few bytes. */
867
868static int
Martin v. Löwis95292d62002-12-11 14:04:59 +0000869maybe_pyc_file(FILE *fp, const char* filename, const char* ext, int closeit)
Martin v. Löwisbe4c0f52001-01-04 20:30:56 +0000870{
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000871 if (strcmp(ext, ".pyc") == 0 || strcmp(ext, ".pyo") == 0)
872 return 1;
Martin v. Löwisbe4c0f52001-01-04 20:30:56 +0000873
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000874 /* Only look into the file if we are allowed to close it, since
875 it then should also be seekable. */
876 if (closeit) {
877 /* Read only two bytes of the magic. If the file was opened in
878 text mode, the bytes 3 and 4 of the magic (\r\n) might not
879 be read as they are on disk. */
880 unsigned int halfmagic = PyImport_GetMagicNumber() & 0xFFFF;
881 unsigned char buf[2];
882 /* Mess: In case of -x, the stream is NOT at its start now,
883 and ungetc() was used to push back the first newline,
884 which makes the current stream position formally undefined,
885 and a x-platform nightmare.
886 Unfortunately, we have no direct way to know whether -x
887 was specified. So we use a terrible hack: if the current
888 stream position is not 0, we assume -x was specified, and
889 give up. Bug 132850 on SourceForge spells out the
890 hopelessness of trying anything else (fseek and ftell
891 don't work predictably x-platform for text-mode files).
892 */
893 int ispyc = 0;
894 if (ftell(fp) == 0) {
895 if (fread(buf, 1, 2, fp) == 2 &&
896 ((unsigned int)buf[1]<<8 | buf[0]) == halfmagic)
897 ispyc = 1;
898 rewind(fp);
899 }
900 return ispyc;
901 }
902 return 0;
Tim Petersd08e3822003-04-17 15:24:21 +0000903}
Martin v. Löwisbe4c0f52001-01-04 20:30:56 +0000904
Guido van Rossum0df002c2000-08-27 19:21:52 +0000905int
Martin v. Löwis95292d62002-12-11 14:04:59 +0000906PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit,
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000907 PyCompilerFlags *flags)
Jeremy Hyltonbc320242001-03-22 02:47:58 +0000908{
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000909 PyObject *m, *d, *v;
910 const char *ext;
911 int set_file_name = 0, ret, len;
Guido van Rossumfdef2711994-09-14 13:31:04 +0000912
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000913 m = PyImport_AddModule("__main__");
914 if (m == NULL)
915 return -1;
916 d = PyModule_GetDict(m);
917 if (PyDict_GetItemString(d, "__file__") == NULL) {
918 PyObject *f = PyString_FromString(filename);
919 if (f == NULL)
920 return -1;
921 if (PyDict_SetItemString(d, "__file__", f) < 0) {
922 Py_DECREF(f);
923 return -1;
924 }
925 set_file_name = 1;
926 Py_DECREF(f);
927 }
928 len = strlen(filename);
929 ext = filename + len - (len > 4 ? 4 : 0);
930 if (maybe_pyc_file(fp, filename, ext, closeit)) {
931 /* Try to run a pyc file. First, re-open in binary */
932 if (closeit)
933 fclose(fp);
934 if ((fp = fopen(filename, "rb")) == NULL) {
935 fprintf(stderr, "python: Can't reopen .pyc file\n");
936 ret = -1;
937 goto done;
938 }
939 /* Turn on optimization if a .pyo file is given */
940 if (strcmp(ext, ".pyo") == 0)
941 Py_OptimizeFlag = 1;
942 v = run_pyc_file(fp, filename, d, d, flags);
943 } else {
944 v = PyRun_FileExFlags(fp, filename, Py_file_input, d, d,
945 closeit, flags);
946 }
947 if (v == NULL) {
948 PyErr_Print();
949 ret = -1;
950 goto done;
951 }
952 Py_DECREF(v);
953 if (Py_FlushLine())
954 PyErr_Clear();
955 ret = 0;
Georg Brandlaa2321b2007-03-07 00:40:28 +0000956 done:
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000957 if (set_file_name && PyDict_DelItemString(d, "__file__"))
958 PyErr_Clear();
959 return ret;
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000960}
961
962int
Martin v. Löwis95292d62002-12-11 14:04:59 +0000963PyRun_SimpleStringFlags(const char *command, PyCompilerFlags *flags)
Guido van Rossum393661d2001-08-31 17:40:15 +0000964{
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000965 PyObject *m, *d, *v;
966 m = PyImport_AddModule("__main__");
967 if (m == NULL)
968 return -1;
969 d = PyModule_GetDict(m);
970 v = PyRun_StringFlags(command, Py_file_input, d, d, flags);
971 if (v == NULL) {
972 PyErr_Print();
973 return -1;
974 }
975 Py_DECREF(v);
976 if (Py_FlushLine())
977 PyErr_Clear();
978 return 0;
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000979}
980
Barry Warsaw035574d1997-08-29 22:07:17 +0000981static int
Martin v. Löwis95292d62002-12-11 14:04:59 +0000982parse_syntax_error(PyObject *err, PyObject **message, const char **filename,
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000983 int *lineno, int *offset, const char **text)
Barry Warsaw035574d1997-08-29 22:07:17 +0000984{
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000985 long hold;
986 PyObject *v;
Barry Warsaw035574d1997-08-29 22:07:17 +0000987
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000988 /* old style errors */
989 if (PyTuple_Check(err))
990 return PyArg_ParseTuple(err, "O(ziiz)", message, filename,
991 lineno, offset, text);
Barry Warsaw035574d1997-08-29 22:07:17 +0000992
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000993 /* new style errors. `err' is an instance */
Barry Warsaw035574d1997-08-29 22:07:17 +0000994
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000995 if (! (v = PyObject_GetAttrString(err, "msg")))
996 goto finally;
997 *message = v;
Barry Warsaw035574d1997-08-29 22:07:17 +0000998
Antoine Pitrouc83ea132010-05-09 14:46:46 +0000999 if (!(v = PyObject_GetAttrString(err, "filename")))
1000 goto finally;
1001 if (v == Py_None)
1002 *filename = NULL;
1003 else if (! (*filename = PyString_AsString(v)))
1004 goto finally;
Barry Warsaw035574d1997-08-29 22:07:17 +00001005
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001006 Py_DECREF(v);
1007 if (!(v = PyObject_GetAttrString(err, "lineno")))
1008 goto finally;
1009 hold = PyInt_AsLong(v);
1010 Py_DECREF(v);
1011 v = NULL;
1012 if (hold < 0 && PyErr_Occurred())
1013 goto finally;
1014 *lineno = (int)hold;
Barry Warsaw035574d1997-08-29 22:07:17 +00001015
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001016 if (!(v = PyObject_GetAttrString(err, "offset")))
1017 goto finally;
1018 if (v == Py_None) {
1019 *offset = -1;
1020 Py_DECREF(v);
1021 v = NULL;
1022 } else {
1023 hold = PyInt_AsLong(v);
1024 Py_DECREF(v);
1025 v = NULL;
1026 if (hold < 0 && PyErr_Occurred())
1027 goto finally;
1028 *offset = (int)hold;
1029 }
Barry Warsaw035574d1997-08-29 22:07:17 +00001030
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001031 if (!(v = PyObject_GetAttrString(err, "text")))
1032 goto finally;
1033 if (v == Py_None)
1034 *text = NULL;
1035 else if (! (*text = PyString_AsString(v)))
1036 goto finally;
1037 Py_DECREF(v);
1038 return 1;
Barry Warsaw035574d1997-08-29 22:07:17 +00001039
1040finally:
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001041 Py_XDECREF(v);
1042 return 0;
Barry Warsaw035574d1997-08-29 22:07:17 +00001043}
1044
Guido van Rossum1984f1e1992-08-04 12:41:02 +00001045void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001046PyErr_Print(void)
Guido van Rossum1984f1e1992-08-04 12:41:02 +00001047{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001048 PyErr_PrintEx(1);
Guido van Rossuma61691e1998-02-06 22:27:24 +00001049}
1050
Jeremy Hylton9f1b9932001-02-28 07:07:43 +00001051static void
Martin v. Löwis95292d62002-12-11 14:04:59 +00001052print_error_text(PyObject *f, int offset, const char *text)
Jeremy Hylton9f1b9932001-02-28 07:07:43 +00001053{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001054 char *nl;
1055 if (offset >= 0) {
Benjamin Petersonec9f9f52010-10-29 03:45:34 +00001056 if (offset > 0 && offset == strlen(text) && text[offset - 1] == '\n')
1057 offset--;
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001058 for (;;) {
1059 nl = strchr(text, '\n');
1060 if (nl == NULL || nl-text >= offset)
1061 break;
1062 offset -= (int)(nl+1-text);
1063 text = nl+1;
1064 }
1065 while (*text == ' ' || *text == '\t') {
1066 text++;
1067 offset--;
1068 }
1069 }
1070 PyFile_WriteString(" ", f);
1071 PyFile_WriteString(text, f);
1072 if (*text == '\0' || text[strlen(text)-1] != '\n')
1073 PyFile_WriteString("\n", f);
1074 if (offset == -1)
1075 return;
1076 PyFile_WriteString(" ", f);
1077 offset--;
1078 while (offset > 0) {
1079 PyFile_WriteString(" ", f);
1080 offset--;
1081 }
1082 PyFile_WriteString("^\n", f);
Jeremy Hylton9f1b9932001-02-28 07:07:43 +00001083}
1084
Guido van Rossum66e8e862001-03-23 17:54:43 +00001085static void
1086handle_system_exit(void)
Ka-Ping Yee26fabb02001-03-23 15:36:41 +00001087{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001088 PyObject *exception, *value, *tb;
1089 int exitcode = 0;
Tim Peterscf615b52003-04-19 18:47:02 +00001090
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001091 if (Py_InspectFlag)
1092 /* Don't exit if -i flag was given. This flag is set to 0
1093 * when entering interactive mode for inspecting. */
1094 return;
Georg Brandl49aafc92007-03-07 00:34:46 +00001095
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001096 PyErr_Fetch(&exception, &value, &tb);
1097 if (Py_FlushLine())
1098 PyErr_Clear();
1099 fflush(stdout);
1100 if (value == NULL || value == Py_None)
1101 goto done;
1102 if (PyExceptionInstance_Check(value)) {
1103 /* The error code should be in the `code' attribute. */
1104 PyObject *code = PyObject_GetAttrString(value, "code");
1105 if (code) {
1106 Py_DECREF(value);
1107 value = code;
1108 if (value == Py_None)
1109 goto done;
1110 }
1111 /* If we failed to dig out the 'code' attribute,
1112 just let the else clause below print the error. */
1113 }
1114 if (PyInt_Check(value))
1115 exitcode = (int)PyInt_AsLong(value);
1116 else {
Victor Stinnerc49dfcc2010-05-25 22:30:32 +00001117 PyObject *sys_stderr = PySys_GetObject("stderr");
1118 if (sys_stderr != NULL && sys_stderr != Py_None) {
1119 PyFile_WriteObject(value, sys_stderr, Py_PRINT_RAW);
1120 } else {
1121 PyObject_Print(value, stderr, Py_PRINT_RAW);
1122 fflush(stderr);
1123 }
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001124 PySys_WriteStderr("\n");
1125 exitcode = 1;
1126 }
Tim Peterscf615b52003-04-19 18:47:02 +00001127 done:
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001128 /* Restore and clear the exception info, in order to properly decref
1129 * the exception, value, and traceback. If we just exit instead,
1130 * these leak, which confuses PYTHONDUMPREFS output, and may prevent
1131 * some finalizers from running.
1132 */
1133 PyErr_Restore(exception, value, tb);
1134 PyErr_Clear();
1135 Py_Exit(exitcode);
1136 /* NOTREACHED */
Ka-Ping Yee26fabb02001-03-23 15:36:41 +00001137}
1138
1139void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001140PyErr_PrintEx(int set_sys_last_vars)
Guido van Rossuma61691e1998-02-06 22:27:24 +00001141{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001142 PyObject *exception, *v, *tb, *hook;
Guido van Rossum66e8e862001-03-23 17:54:43 +00001143
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001144 if (PyErr_ExceptionMatches(PyExc_SystemExit)) {
1145 handle_system_exit();
1146 }
1147 PyErr_Fetch(&exception, &v, &tb);
1148 if (exception == NULL)
1149 return;
1150 PyErr_NormalizeException(&exception, &v, &tb);
1151 if (exception == NULL)
1152 return;
1153 /* Now we know v != NULL too */
1154 if (set_sys_last_vars) {
1155 PySys_SetObject("last_type", exception);
1156 PySys_SetObject("last_value", v);
1157 PySys_SetObject("last_traceback", tb);
1158 }
1159 hook = PySys_GetObject("excepthook");
Antoine Pitroua03ff6d2010-08-08 21:37:51 +00001160 if (hook && hook != Py_None) {
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001161 PyObject *args = PyTuple_Pack(3,
1162 exception, v, tb ? tb : Py_None);
1163 PyObject *result = PyEval_CallObject(hook, args);
1164 if (result == NULL) {
1165 PyObject *exception2, *v2, *tb2;
1166 if (PyErr_ExceptionMatches(PyExc_SystemExit)) {
1167 handle_system_exit();
1168 }
1169 PyErr_Fetch(&exception2, &v2, &tb2);
1170 PyErr_NormalizeException(&exception2, &v2, &tb2);
1171 /* It should not be possible for exception2 or v2
1172 to be NULL. However PyErr_Display() can't
1173 tolerate NULLs, so just be safe. */
1174 if (exception2 == NULL) {
1175 exception2 = Py_None;
1176 Py_INCREF(exception2);
1177 }
1178 if (v2 == NULL) {
1179 v2 = Py_None;
1180 Py_INCREF(v2);
1181 }
1182 if (Py_FlushLine())
1183 PyErr_Clear();
1184 fflush(stdout);
1185 PySys_WriteStderr("Error in sys.excepthook:\n");
1186 PyErr_Display(exception2, v2, tb2);
1187 PySys_WriteStderr("\nOriginal exception was:\n");
1188 PyErr_Display(exception, v, tb);
1189 Py_DECREF(exception2);
1190 Py_DECREF(v2);
1191 Py_XDECREF(tb2);
1192 }
1193 Py_XDECREF(result);
1194 Py_XDECREF(args);
1195 } else {
1196 PySys_WriteStderr("sys.excepthook is missing\n");
1197 PyErr_Display(exception, v, tb);
1198 }
1199 Py_XDECREF(exception);
1200 Py_XDECREF(v);
1201 Py_XDECREF(tb);
Ka-Ping Yeeb5c51322001-03-23 02:46:52 +00001202}
1203
Richard Jones7b9558d2006-05-27 12:29:24 +00001204void
1205PyErr_Display(PyObject *exception, PyObject *value, PyObject *tb)
Ka-Ping Yeeb5c51322001-03-23 02:46:52 +00001206{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001207 int err = 0;
1208 PyObject *f = PySys_GetObject("stderr");
1209 Py_INCREF(value);
Antoine Pitroua03ff6d2010-08-08 21:37:51 +00001210 if (f == NULL || f == Py_None)
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001211 fprintf(stderr, "lost sys.stderr\n");
1212 else {
1213 if (Py_FlushLine())
1214 PyErr_Clear();
1215 fflush(stdout);
1216 if (tb && tb != Py_None)
1217 err = PyTraceBack_Print(tb, f);
1218 if (err == 0 &&
1219 PyObject_HasAttrString(value, "print_file_and_line"))
1220 {
1221 PyObject *message;
1222 const char *filename, *text;
1223 int lineno, offset;
1224 if (!parse_syntax_error(value, &message, &filename,
1225 &lineno, &offset, &text))
1226 PyErr_Clear();
1227 else {
1228 char buf[10];
1229 PyFile_WriteString(" File \"", f);
1230 if (filename == NULL)
1231 PyFile_WriteString("<string>", f);
1232 else
1233 PyFile_WriteString(filename, f);
1234 PyFile_WriteString("\", line ", f);
1235 PyOS_snprintf(buf, sizeof(buf), "%d", lineno);
1236 PyFile_WriteString(buf, f);
1237 PyFile_WriteString("\n", f);
1238 if (text != NULL)
1239 print_error_text(f, offset, text);
1240 Py_DECREF(value);
1241 value = message;
1242 /* Can't be bothered to check all those
1243 PyFile_WriteString() calls */
1244 if (PyErr_Occurred())
1245 err = -1;
1246 }
1247 }
1248 if (err) {
1249 /* Don't do anything else */
1250 }
1251 else if (PyExceptionClass_Check(exception)) {
1252 PyObject* moduleName;
1253 char* className = PyExceptionClass_Name(exception);
1254 if (className != NULL) {
1255 char *dot = strrchr(className, '.');
1256 if (dot != NULL)
1257 className = dot+1;
1258 }
Barry Warsaw2f5f6a21997-09-16 21:42:03 +00001259
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001260 moduleName = PyObject_GetAttrString(exception, "__module__");
1261 if (moduleName == NULL)
1262 err = PyFile_WriteString("<unknown>", f);
1263 else {
1264 char* modstr = PyString_AsString(moduleName);
1265 if (modstr && strcmp(modstr, "exceptions"))
1266 {
1267 err = PyFile_WriteString(modstr, f);
1268 err += PyFile_WriteString(".", f);
1269 }
1270 Py_DECREF(moduleName);
1271 }
1272 if (err == 0) {
1273 if (className == NULL)
1274 err = PyFile_WriteString("<unknown>", f);
1275 else
1276 err = PyFile_WriteString(className, f);
1277 }
1278 }
1279 else
1280 err = PyFile_WriteObject(exception, f, Py_PRINT_RAW);
1281 if (err == 0 && (value != Py_None)) {
1282 PyObject *s = PyObject_Str(value);
1283 /* only print colon if the str() of the
1284 object is not the empty string
1285 */
1286 if (s == NULL)
1287 err = -1;
1288 else if (!PyString_Check(s) ||
1289 PyString_GET_SIZE(s) != 0)
1290 err = PyFile_WriteString(": ", f);
1291 if (err == 0)
1292 err = PyFile_WriteObject(s, f, Py_PRINT_RAW);
1293 Py_XDECREF(s);
1294 }
1295 /* try to write a newline in any case */
1296 err += PyFile_WriteString("\n", f);
1297 }
1298 Py_DECREF(value);
1299 /* If an error happened here, don't show it.
1300 XXX This is wrong, but too many callers rely on this behavior. */
1301 if (err != 0)
1302 PyErr_Clear();
Guido van Rossum1984f1e1992-08-04 12:41:02 +00001303}
1304
Guido van Rossum82598051997-03-05 00:20:32 +00001305PyObject *
Tim Peters5e9d6cf2006-05-28 10:41:29 +00001306PyRun_StringFlags(const char *str, int start, PyObject *globals,
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001307 PyObject *locals, PyCompilerFlags *flags)
Guido van Rossum1984f1e1992-08-04 12:41:02 +00001308{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001309 PyObject *ret = NULL;
1310 mod_ty mod;
1311 PyArena *arena = PyArena_New();
1312 if (arena == NULL)
1313 return NULL;
Brett Cannonc33e82d2010-05-05 20:38:52 +00001314
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001315 mod = PyParser_ASTFromString(str, "<string>", start, flags, arena);
1316 if (mod != NULL)
1317 ret = run_mod(mod, "<string>", globals, locals, flags, arena);
1318 PyArena_Free(arena);
1319 return ret;
Jeremy Hyltonbc320242001-03-22 02:47:58 +00001320}
1321
1322PyObject *
Martin v. Löwis95292d62002-12-11 14:04:59 +00001323PyRun_FileExFlags(FILE *fp, const char *filename, int start, PyObject *globals,
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001324 PyObject *locals, int closeit, PyCompilerFlags *flags)
Jeremy Hyltonbc320242001-03-22 02:47:58 +00001325{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001326 PyObject *ret;
1327 mod_ty mod;
1328 PyArena *arena = PyArena_New();
1329 if (arena == NULL)
1330 return NULL;
Brett Cannonc33e82d2010-05-05 20:38:52 +00001331
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001332 mod = PyParser_ASTFromFile(fp, filename, start, 0, 0,
1333 flags, NULL, arena);
1334 if (closeit)
1335 fclose(fp);
1336 if (mod == NULL) {
1337 PyArena_Free(arena);
1338 return NULL;
1339 }
1340 ret = run_mod(mod, filename, globals, locals, flags, arena);
1341 PyArena_Free(arena);
1342 return ret;
Jeremy Hyltonbc320242001-03-22 02:47:58 +00001343}
1344
Guido van Rossum82598051997-03-05 00:20:32 +00001345static PyObject *
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001346run_mod(mod_ty mod, const char *filename, PyObject *globals, PyObject *locals,
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001347 PyCompilerFlags *flags, PyArena *arena)
Guido van Rossum1984f1e1992-08-04 12:41:02 +00001348{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001349 PyCodeObject *co;
1350 PyObject *v;
1351 co = PyAST_Compile(mod, filename, flags, arena);
1352 if (co == NULL)
1353 return NULL;
1354 v = PyEval_EvalCode(co, globals, locals);
1355 Py_DECREF(co);
1356 return v;
Guido van Rossum1984f1e1992-08-04 12:41:02 +00001357}
1358
Guido van Rossum82598051997-03-05 00:20:32 +00001359static PyObject *
Tim Peters5e9d6cf2006-05-28 10:41:29 +00001360run_pyc_file(FILE *fp, const char *filename, PyObject *globals,
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001361 PyObject *locals, PyCompilerFlags *flags)
Guido van Rossumfdef2711994-09-14 13:31:04 +00001362{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001363 PyCodeObject *co;
1364 PyObject *v;
1365 long magic;
1366 long PyImport_GetMagicNumber(void);
Guido van Rossumfdef2711994-09-14 13:31:04 +00001367
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001368 magic = PyMarshal_ReadLongFromFile(fp);
1369 if (magic != PyImport_GetMagicNumber()) {
1370 PyErr_SetString(PyExc_RuntimeError,
1371 "Bad magic number in .pyc file");
1372 return NULL;
1373 }
1374 (void) PyMarshal_ReadLongFromFile(fp);
1375 v = PyMarshal_ReadLastObjectFromFile(fp);
1376 fclose(fp);
1377 if (v == NULL || !PyCode_Check(v)) {
1378 Py_XDECREF(v);
1379 PyErr_SetString(PyExc_RuntimeError,
1380 "Bad code object in .pyc file");
1381 return NULL;
1382 }
1383 co = (PyCodeObject *)v;
1384 v = PyEval_EvalCode(co, globals, locals);
1385 if (v && flags)
1386 flags->cf_flags |= (co->co_flags & PyCF_MASK);
1387 Py_DECREF(co);
1388 return v;
Guido van Rossumfdef2711994-09-14 13:31:04 +00001389}
1390
Guido van Rossum82598051997-03-05 00:20:32 +00001391PyObject *
Tim Petersd08e3822003-04-17 15:24:21 +00001392Py_CompileStringFlags(const char *str, const char *filename, int start,
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001393 PyCompilerFlags *flags)
Jeremy Hyltonbc320242001-03-22 02:47:58 +00001394{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001395 PyCodeObject *co;
1396 mod_ty mod;
1397 PyArena *arena = PyArena_New();
1398 if (arena == NULL)
1399 return NULL;
Neal Norwitzb59d08c2006-07-22 16:20:49 +00001400
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001401 mod = PyParser_ASTFromString(str, filename, start, flags, arena);
1402 if (mod == NULL) {
1403 PyArena_Free(arena);
1404 return NULL;
1405 }
1406 if (flags && (flags->cf_flags & PyCF_ONLY_AST)) {
1407 PyObject *result = PyAST_mod2obj(mod);
1408 PyArena_Free(arena);
1409 return result;
1410 }
1411 co = PyAST_Compile(mod, filename, flags, arena);
1412 PyArena_Free(arena);
1413 return (PyObject *)co;
Guido van Rossum5b722181993-03-30 17:46:03 +00001414}
1415
Jeremy Hylton4b38da62001-02-02 18:19:15 +00001416struct symtable *
Martin v. Löwis95292d62002-12-11 14:04:59 +00001417Py_SymtableString(const char *str, const char *filename, int start)
Jeremy Hylton4b38da62001-02-02 18:19:15 +00001418{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001419 struct symtable *st;
1420 mod_ty mod;
1421 PyCompilerFlags flags;
1422 PyArena *arena = PyArena_New();
1423 if (arena == NULL)
1424 return NULL;
Neal Norwitzb59d08c2006-07-22 16:20:49 +00001425
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001426 flags.cf_flags = 0;
Christian Heimes7f23d862008-03-26 22:51:58 +00001427
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001428 mod = PyParser_ASTFromString(str, filename, start, &flags, arena);
1429 if (mod == NULL) {
1430 PyArena_Free(arena);
1431 return NULL;
1432 }
1433 st = PySymtable_Build(mod, filename, 0);
1434 PyArena_Free(arena);
1435 return st;
Jeremy Hylton4b38da62001-02-02 18:19:15 +00001436}
1437
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001438/* Preferred access to parser is through AST. */
1439mod_ty
Tim Peters5e9d6cf2006-05-28 10:41:29 +00001440PyParser_ASTFromString(const char *s, const char *filename, int start,
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001441 PyCompilerFlags *flags, PyArena *arena)
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001442{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001443 mod_ty mod;
1444 PyCompilerFlags localflags;
1445 perrdetail err;
1446 int iflags = PARSER_FLAGS(flags);
Christian Heimes3c608332008-03-26 22:01:37 +00001447
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001448 node *n = PyParser_ParseStringFlagsFilenameEx(s, filename,
1449 &_PyParser_Grammar, start, &err,
1450 &iflags);
1451 if (flags == NULL) {
1452 localflags.cf_flags = 0;
1453 flags = &localflags;
1454 }
1455 if (n) {
1456 flags->cf_flags |= iflags & PyCF_MASK;
1457 mod = PyAST_FromNode(n, flags, filename, arena);
1458 PyNode_Free(n);
1459 return mod;
1460 }
1461 else {
1462 err_input(&err);
1463 return NULL;
1464 }
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001465}
1466
1467mod_ty
Tim Peters5e9d6cf2006-05-28 10:41:29 +00001468PyParser_ASTFromFile(FILE *fp, const char *filename, int start, char *ps1,
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001469 char *ps2, PyCompilerFlags *flags, int *errcode,
1470 PyArena *arena)
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001471{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001472 mod_ty mod;
1473 PyCompilerFlags localflags;
1474 perrdetail err;
1475 int iflags = PARSER_FLAGS(flags);
Christian Heimes3c608332008-03-26 22:01:37 +00001476
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001477 node *n = PyParser_ParseFileFlagsEx(fp, filename, &_PyParser_Grammar,
1478 start, ps1, ps2, &err, &iflags);
1479 if (flags == NULL) {
1480 localflags.cf_flags = 0;
1481 flags = &localflags;
1482 }
1483 if (n) {
1484 flags->cf_flags |= iflags & PyCF_MASK;
1485 mod = PyAST_FromNode(n, flags, filename, arena);
1486 PyNode_Free(n);
1487 return mod;
1488 }
1489 else {
1490 err_input(&err);
1491 if (errcode)
1492 *errcode = err.error;
1493 return NULL;
1494 }
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001495}
1496
Guido van Rossuma110aa61994-08-29 12:50:44 +00001497/* Simplified interface to parsefile -- return node or set exception */
Guido van Rossum1984f1e1992-08-04 12:41:02 +00001498
Guido van Rossuma110aa61994-08-29 12:50:44 +00001499node *
Martin v. Löwis95292d62002-12-11 14:04:59 +00001500PyParser_SimpleParseFileFlags(FILE *fp, const char *filename, int start, int flags)
Guido van Rossum1984f1e1992-08-04 12:41:02 +00001501{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001502 perrdetail err;
1503 node *n = PyParser_ParseFileFlags(fp, filename, &_PyParser_Grammar,
1504 start, NULL, NULL, &err, flags);
1505 if (n == NULL)
1506 err_input(&err);
Tim Peters5e9d6cf2006-05-28 10:41:29 +00001507
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001508 return n;
Guido van Rossum1984f1e1992-08-04 12:41:02 +00001509}
1510
Guido van Rossuma110aa61994-08-29 12:50:44 +00001511/* Simplified interface to parsestring -- return node or set exception */
Guido van Rossum1984f1e1992-08-04 12:41:02 +00001512
Guido van Rossuma110aa61994-08-29 12:50:44 +00001513node *
Martin v. Löwis95292d62002-12-11 14:04:59 +00001514PyParser_SimpleParseStringFlags(const char *str, int start, int flags)
Tim Petersfe2127d2001-07-16 05:37:24 +00001515{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001516 perrdetail err;
1517 node *n = PyParser_ParseStringFlags(str, &_PyParser_Grammar,
1518 start, &err, flags);
1519 if (n == NULL)
1520 err_input(&err);
1521 return n;
Tim Petersfe2127d2001-07-16 05:37:24 +00001522}
1523
1524node *
Martin v. Löwis95292d62002-12-11 14:04:59 +00001525PyParser_SimpleParseStringFlagsFilename(const char *str, const char *filename,
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001526 int start, int flags)
Thomas Heller6b17abf2002-07-09 09:23:27 +00001527{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001528 perrdetail err;
1529 node *n = PyParser_ParseStringFlagsFilename(str, filename,
1530 &_PyParser_Grammar, start, &err, flags);
1531 if (n == NULL)
1532 err_input(&err);
1533 return n;
Thomas Heller6b17abf2002-07-09 09:23:27 +00001534}
1535
1536node *
Martin v. Löwis95292d62002-12-11 14:04:59 +00001537PyParser_SimpleParseStringFilename(const char *str, const char *filename, int start)
Thomas Heller6b17abf2002-07-09 09:23:27 +00001538{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001539 return PyParser_SimpleParseStringFlagsFilename(str, filename, start, 0);
Thomas Heller6b17abf2002-07-09 09:23:27 +00001540}
1541
Guido van Rossum66ebd912003-04-17 16:02:26 +00001542/* May want to move a more generalized form of this to parsetok.c or
1543 even parser modules. */
1544
1545void
1546PyParser_SetError(perrdetail *err)
1547{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001548 err_input(err);
Guido van Rossum66ebd912003-04-17 16:02:26 +00001549}
1550
Guido van Rossuma110aa61994-08-29 12:50:44 +00001551/* Set the error appropriate to the given input error code (see errcode.h) */
1552
1553static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001554err_input(perrdetail *err)
Guido van Rossuma110aa61994-08-29 12:50:44 +00001555{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001556 PyObject *v, *w, *errtype;
1557 PyObject* u = NULL;
1558 char *msg = NULL;
1559 errtype = PyExc_SyntaxError;
1560 switch (err->error) {
1561 case E_ERROR:
1562 return;
1563 case E_SYNTAX:
1564 errtype = PyExc_IndentationError;
1565 if (err->expected == INDENT)
1566 msg = "expected an indented block";
1567 else if (err->token == INDENT)
1568 msg = "unexpected indent";
1569 else if (err->token == DEDENT)
1570 msg = "unexpected unindent";
1571 else {
1572 errtype = PyExc_SyntaxError;
1573 msg = "invalid syntax";
1574 }
1575 break;
1576 case E_TOKEN:
1577 msg = "invalid token";
1578 break;
1579 case E_EOFS:
1580 msg = "EOF while scanning triple-quoted string literal";
1581 break;
1582 case E_EOLS:
1583 msg = "EOL while scanning string literal";
1584 break;
1585 case E_INTR:
1586 if (!PyErr_Occurred())
1587 PyErr_SetNone(PyExc_KeyboardInterrupt);
1588 goto cleanup;
1589 case E_NOMEM:
1590 PyErr_NoMemory();
1591 goto cleanup;
1592 case E_EOF:
1593 msg = "unexpected EOF while parsing";
1594 break;
1595 case E_TABSPACE:
1596 errtype = PyExc_TabError;
1597 msg = "inconsistent use of tabs and spaces in indentation";
1598 break;
1599 case E_OVERFLOW:
1600 msg = "expression too long";
1601 break;
1602 case E_DEDENT:
1603 errtype = PyExc_IndentationError;
1604 msg = "unindent does not match any outer indentation level";
1605 break;
1606 case E_TOODEEP:
1607 errtype = PyExc_IndentationError;
1608 msg = "too many levels of indentation";
1609 break;
1610 case E_DECODE: {
1611 PyObject *type, *value, *tb;
1612 PyErr_Fetch(&type, &value, &tb);
1613 if (value != NULL) {
1614 u = PyObject_Str(value);
1615 if (u != NULL) {
1616 msg = PyString_AsString(u);
1617 }
1618 }
1619 if (msg == NULL)
1620 msg = "unknown decode error";
1621 Py_XDECREF(type);
1622 Py_XDECREF(value);
1623 Py_XDECREF(tb);
1624 break;
1625 }
1626 case E_LINECONT:
1627 msg = "unexpected character after line continuation character";
1628 break;
1629 default:
1630 fprintf(stderr, "error=%d\n", err->error);
1631 msg = "unknown parsing error";
1632 break;
1633 }
1634 v = Py_BuildValue("(ziiz)", err->filename,
1635 err->lineno, err->offset, err->text);
1636 w = NULL;
1637 if (v != NULL)
1638 w = Py_BuildValue("(sO)", msg, v);
1639 Py_XDECREF(u);
1640 Py_XDECREF(v);
1641 PyErr_SetObject(errtype, w);
1642 Py_XDECREF(w);
Georg Brandl1ad108d2008-07-19 10:08:55 +00001643cleanup:
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001644 if (err->text != NULL) {
1645 PyObject_FREE(err->text);
1646 err->text = NULL;
1647 }
Guido van Rossum1984f1e1992-08-04 12:41:02 +00001648}
1649
1650/* Print fatal error message and abort */
1651
1652void
Tim Peters7c321a82002-07-09 02:57:01 +00001653Py_FatalError(const char *msg)
Guido van Rossum1984f1e1992-08-04 12:41:02 +00001654{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001655 fprintf(stderr, "Fatal Python error: %s\n", msg);
1656 fflush(stderr); /* it helps in Windows debug build */
Jesse Noller42f9b4e2009-03-31 22:20:35 +00001657
Martin v. Löwis6238d2b2002-06-30 15:26:10 +00001658#ifdef MS_WINDOWS
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001659 {
1660 size_t len = strlen(msg);
1661 WCHAR* buffer;
1662 size_t i;
Martin v. Löwis5344c992009-01-02 20:32:55 +00001663
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001664 /* Convert the message to wchar_t. This uses a simple one-to-one
1665 conversion, assuming that the this error message actually uses ASCII
1666 only. If this ceases to be true, we will have to convert. */
1667 buffer = alloca( (len+1) * (sizeof *buffer));
1668 for( i=0; i<=len; ++i)
1669 buffer[i] = msg[i];
1670 OutputDebugStringW(L"Fatal Python error: ");
1671 OutputDebugStringW(buffer);
1672 OutputDebugStringW(L"\n");
1673 }
Guido van Rossum0ba35361998-08-13 13:33:16 +00001674#ifdef _DEBUG
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001675 DebugBreak();
Guido van Rossuma44823b1995-03-14 15:01:17 +00001676#endif
Martin v. Löwis6238d2b2002-06-30 15:26:10 +00001677#endif /* MS_WINDOWS */
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001678 abort();
Guido van Rossum1984f1e1992-08-04 12:41:02 +00001679}
1680
1681/* Clean up and exit */
1682
Guido van Rossuma110aa61994-08-29 12:50:44 +00001683#ifdef WITH_THREAD
Guido van Rossum49b56061998-10-01 20:42:43 +00001684#include "pythread.h"
Guido van Rossumf9f2e821992-08-17 08:59:08 +00001685#endif
1686
Antoine Pitrouefb60c02009-10-20 21:29:37 +00001687/* Wait until threading._shutdown completes, provided
1688 the threading module was imported in the first place.
1689 The shutdown routine will wait until all non-daemon
1690 "threading" threads have completed. */
1691static void
1692wait_for_thread_shutdown(void)
1693{
1694#ifdef WITH_THREAD
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001695 PyObject *result;
1696 PyThreadState *tstate = PyThreadState_GET();
1697 PyObject *threading = PyMapping_GetItemString(tstate->interp->modules,
1698 "threading");
1699 if (threading == NULL) {
1700 /* threading not imported */
1701 PyErr_Clear();
1702 return;
1703 }
1704 result = PyObject_CallMethod(threading, "_shutdown", "");
1705 if (result == NULL)
1706 PyErr_WriteUnraisable(threading);
1707 else
1708 Py_DECREF(result);
1709 Py_DECREF(threading);
Antoine Pitrouefb60c02009-10-20 21:29:37 +00001710#endif
1711}
1712
Guido van Rossum2dcfc961998-10-01 16:01:57 +00001713#define NEXITFUNCS 32
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001714static void (*exitfuncs[NEXITFUNCS])(void);
Guido van Rossum1662dd51994-09-07 14:38:28 +00001715static int nexitfuncs = 0;
1716
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001717int Py_AtExit(void (*func)(void))
Guido van Rossum1662dd51994-09-07 14:38:28 +00001718{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001719 if (nexitfuncs >= NEXITFUNCS)
1720 return -1;
1721 exitfuncs[nexitfuncs++] = func;
1722 return 0;
Guido van Rossum1662dd51994-09-07 14:38:28 +00001723}
1724
Guido van Rossumcc283f51997-08-05 02:22:03 +00001725static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001726call_sys_exitfunc(void)
Guido van Rossum1984f1e1992-08-04 12:41:02 +00001727{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001728 PyObject *exitfunc = PySys_GetObject("exitfunc");
Guido van Rossum59bff391992-09-03 20:28:00 +00001729
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001730 if (exitfunc) {
1731 PyObject *res;
1732 Py_INCREF(exitfunc);
1733 PySys_SetObject("exitfunc", (PyObject *)NULL);
1734 res = PyEval_CallObject(exitfunc, (PyObject *)NULL);
1735 if (res == NULL) {
1736 if (!PyErr_ExceptionMatches(PyExc_SystemExit)) {
1737 PySys_WriteStderr("Error in sys.exitfunc:\n");
1738 }
1739 PyErr_Print();
1740 }
1741 Py_DECREF(exitfunc);
1742 }
Guido van Rossum59bff391992-09-03 20:28:00 +00001743
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001744 if (Py_FlushLine())
1745 PyErr_Clear();
Guido van Rossumcc283f51997-08-05 02:22:03 +00001746}
Guido van Rossum1662dd51994-09-07 14:38:28 +00001747
Guido van Rossumcc283f51997-08-05 02:22:03 +00001748static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001749call_ll_exitfuncs(void)
Guido van Rossumcc283f51997-08-05 02:22:03 +00001750{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001751 while (nexitfuncs > 0)
1752 (*exitfuncs[--nexitfuncs])();
Guido van Rossum25ce5661997-08-02 03:10:38 +00001753
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001754 fflush(stdout);
1755 fflush(stderr);
Guido van Rossuma9e7dc11992-10-18 18:53:57 +00001756}
1757
1758void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001759Py_Exit(int sts)
Guido van Rossuma9e7dc11992-10-18 18:53:57 +00001760{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001761 Py_Finalize();
Guido van Rossum1984f1e1992-08-04 12:41:02 +00001762
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001763 exit(sts);
Guido van Rossum1984f1e1992-08-04 12:41:02 +00001764}
1765
Guido van Rossumf1dc5661993-07-05 10:31:29 +00001766static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001767initsigs(void)
Guido van Rossuma9e7dc11992-10-18 18:53:57 +00001768{
Guido van Rossuma110aa61994-08-29 12:50:44 +00001769#ifdef SIGPIPE
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001770 PyOS_setsig(SIGPIPE, SIG_IGN);
Guido van Rossuma9e7dc11992-10-18 18:53:57 +00001771#endif
Guido van Rossum70d893a2001-08-16 08:21:42 +00001772#ifdef SIGXFZ
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001773 PyOS_setsig(SIGXFZ, SIG_IGN);
Guido van Rossum70d893a2001-08-16 08:21:42 +00001774#endif
Jeremy Hylton1b0bf9b2002-04-23 20:31:01 +00001775#ifdef SIGXFSZ
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001776 PyOS_setsig(SIGXFSZ, SIG_IGN);
Jeremy Hylton1b0bf9b2002-04-23 20:31:01 +00001777#endif
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001778 PyOS_InitInterrupts(); /* May imply initsignal() */
Guido van Rossuma9e7dc11992-10-18 18:53:57 +00001779}
1780
Guido van Rossum7433b121997-02-14 19:45:36 +00001781
1782/*
1783 * The file descriptor fd is considered ``interactive'' if either
1784 * a) isatty(fd) is TRUE, or
1785 * b) the -i flag was given, and the filename associated with
1786 * the descriptor is NULL or "<stdin>" or "???".
1787 */
1788int
Martin v. Löwis95292d62002-12-11 14:04:59 +00001789Py_FdIsInteractive(FILE *fp, const char *filename)
Guido van Rossum7433b121997-02-14 19:45:36 +00001790{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001791 if (isatty((int)fileno(fp)))
1792 return 1;
1793 if (!Py_InteractiveFlag)
1794 return 0;
1795 return (filename == NULL) ||
1796 (strcmp(filename, "<stdin>") == 0) ||
1797 (strcmp(filename, "???") == 0);
Guido van Rossum7433b121997-02-14 19:45:36 +00001798}
Fredrik Lundh2f15b252000-08-27 19:15:31 +00001799
1800
Tim Petersd08e3822003-04-17 15:24:21 +00001801#if defined(USE_STACKCHECK)
Fredrik Lundh2f15b252000-08-27 19:15:31 +00001802#if defined(WIN32) && defined(_MSC_VER)
1803
1804/* Stack checking for Microsoft C */
1805
1806#include <malloc.h>
1807#include <excpt.h>
1808
Fred Drakee8de31c2000-08-31 05:38:39 +00001809/*
1810 * Return non-zero when we run out of memory on the stack; zero otherwise.
1811 */
Fredrik Lundh2f15b252000-08-27 19:15:31 +00001812int
Fred Drake399739f2000-08-31 05:52:44 +00001813PyOS_CheckStack(void)
Fredrik Lundh2f15b252000-08-27 19:15:31 +00001814{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001815 __try {
1816 /* alloca throws a stack overflow exception if there's
1817 not enough space left on the stack */
1818 alloca(PYOS_STACK_MARGIN * sizeof(void*));
1819 return 0;
1820 } __except (GetExceptionCode() == STATUS_STACK_OVERFLOW ?
1821 EXCEPTION_EXECUTE_HANDLER :
1822 EXCEPTION_CONTINUE_SEARCH) {
1823 int errcode = _resetstkoflw();
1824 if (errcode == 0)
1825 {
1826 Py_FatalError("Could not reset the stack!");
1827 }
1828 }
1829 return 1;
Fredrik Lundh2f15b252000-08-27 19:15:31 +00001830}
1831
1832#endif /* WIN32 && _MSC_VER */
1833
1834/* Alternate implementations can be added here... */
1835
1836#endif /* USE_STACKCHECK */
Guido van Rossum6f256182000-09-16 16:32:19 +00001837
1838
1839/* Wrappers around sigaction() or signal(). */
1840
1841PyOS_sighandler_t
1842PyOS_getsig(int sig)
1843{
1844#ifdef HAVE_SIGACTION
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001845 struct sigaction context;
1846 if (sigaction(sig, NULL, &context) == -1)
1847 return SIG_ERR;
1848 return context.sa_handler;
Guido van Rossum6f256182000-09-16 16:32:19 +00001849#else
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001850 PyOS_sighandler_t handler;
Martin v. Löwisb45b3152005-11-28 17:34:23 +00001851/* Special signal handling for the secure CRT in Visual Studio 2005 */
1852#if defined(_MSC_VER) && _MSC_VER >= 1400
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001853 switch (sig) {
1854 /* Only these signals are valid */
1855 case SIGINT:
1856 case SIGILL:
1857 case SIGFPE:
1858 case SIGSEGV:
1859 case SIGTERM:
1860 case SIGBREAK:
1861 case SIGABRT:
1862 break;
1863 /* Don't call signal() with other values or it will assert */
1864 default:
1865 return SIG_ERR;
1866 }
Martin v. Löwisb45b3152005-11-28 17:34:23 +00001867#endif /* _MSC_VER && _MSC_VER >= 1400 */
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001868 handler = signal(sig, SIG_IGN);
1869 if (handler != SIG_ERR)
1870 signal(sig, handler);
1871 return handler;
Guido van Rossum6f256182000-09-16 16:32:19 +00001872#endif
1873}
1874
1875PyOS_sighandler_t
1876PyOS_setsig(int sig, PyOS_sighandler_t handler)
1877{
1878#ifdef HAVE_SIGACTION
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001879 /* Some code in Modules/signalmodule.c depends on sigaction() being
1880 * used here if HAVE_SIGACTION is defined. Fix that if this code
1881 * changes to invalidate that assumption.
1882 */
1883 struct sigaction context, ocontext;
1884 context.sa_handler = handler;
1885 sigemptyset(&context.sa_mask);
1886 context.sa_flags = 0;
1887 if (sigaction(sig, &context, &ocontext) == -1)
1888 return SIG_ERR;
1889 return ocontext.sa_handler;
Guido van Rossum6f256182000-09-16 16:32:19 +00001890#else
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001891 PyOS_sighandler_t oldhandler;
1892 oldhandler = signal(sig, handler);
Anthony Baxter9ceaa722004-10-13 14:48:50 +00001893#ifdef HAVE_SIGINTERRUPT
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001894 siginterrupt(sig, 1);
Anthony Baxter9ceaa722004-10-13 14:48:50 +00001895#endif
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001896 return oldhandler;
Guido van Rossum6f256182000-09-16 16:32:19 +00001897#endif
1898}
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001899
1900/* Deprecated C API functions still provided for binary compatiblity */
1901
1902#undef PyParser_SimpleParseFile
Thomas Heller1b046642006-04-18 18:51:06 +00001903PyAPI_FUNC(node *)
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001904PyParser_SimpleParseFile(FILE *fp, const char *filename, int start)
1905{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001906 return PyParser_SimpleParseFileFlags(fp, filename, start, 0);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001907}
1908
Thomas Heller1b046642006-04-18 18:51:06 +00001909#undef PyParser_SimpleParseString
1910PyAPI_FUNC(node *)
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001911PyParser_SimpleParseString(const char *str, int start)
1912{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001913 return PyParser_SimpleParseStringFlags(str, start, 0);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001914}
Anthony Baxterac6bd462006-04-13 02:06:09 +00001915
Thomas Heller1b046642006-04-18 18:51:06 +00001916#undef PyRun_AnyFile
1917PyAPI_FUNC(int)
1918PyRun_AnyFile(FILE *fp, const char *name)
1919{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001920 return PyRun_AnyFileExFlags(fp, name, 0, NULL);
Thomas Heller1b046642006-04-18 18:51:06 +00001921}
1922
1923#undef PyRun_AnyFileEx
1924PyAPI_FUNC(int)
1925PyRun_AnyFileEx(FILE *fp, const char *name, int closeit)
1926{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001927 return PyRun_AnyFileExFlags(fp, name, closeit, NULL);
Thomas Heller1b046642006-04-18 18:51:06 +00001928}
1929
1930#undef PyRun_AnyFileFlags
1931PyAPI_FUNC(int)
1932PyRun_AnyFileFlags(FILE *fp, const char *name, PyCompilerFlags *flags)
1933{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001934 return PyRun_AnyFileExFlags(fp, name, 0, flags);
Thomas Heller1b046642006-04-18 18:51:06 +00001935}
1936
1937#undef PyRun_File
1938PyAPI_FUNC(PyObject *)
1939PyRun_File(FILE *fp, const char *p, int s, PyObject *g, PyObject *l)
1940{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001941 return PyRun_FileExFlags(fp, p, s, g, l, 0, NULL);
Thomas Heller1b046642006-04-18 18:51:06 +00001942}
1943
1944#undef PyRun_FileEx
1945PyAPI_FUNC(PyObject *)
1946PyRun_FileEx(FILE *fp, const char *p, int s, PyObject *g, PyObject *l, int c)
1947{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001948 return PyRun_FileExFlags(fp, p, s, g, l, c, NULL);
Thomas Heller1b046642006-04-18 18:51:06 +00001949}
1950
1951#undef PyRun_FileFlags
1952PyAPI_FUNC(PyObject *)
1953PyRun_FileFlags(FILE *fp, const char *p, int s, PyObject *g, PyObject *l,
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001954 PyCompilerFlags *flags)
Thomas Heller1b046642006-04-18 18:51:06 +00001955{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001956 return PyRun_FileExFlags(fp, p, s, g, l, 0, flags);
Thomas Heller1b046642006-04-18 18:51:06 +00001957}
1958
1959#undef PyRun_SimpleFile
1960PyAPI_FUNC(int)
1961PyRun_SimpleFile(FILE *f, const char *p)
1962{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001963 return PyRun_SimpleFileExFlags(f, p, 0, NULL);
Thomas Heller1b046642006-04-18 18:51:06 +00001964}
1965
1966#undef PyRun_SimpleFileEx
1967PyAPI_FUNC(int)
1968PyRun_SimpleFileEx(FILE *f, const char *p, int c)
1969{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001970 return PyRun_SimpleFileExFlags(f, p, c, NULL);
Thomas Heller1b046642006-04-18 18:51:06 +00001971}
1972
1973
1974#undef PyRun_String
1975PyAPI_FUNC(PyObject *)
1976PyRun_String(const char *str, int s, PyObject *g, PyObject *l)
1977{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001978 return PyRun_StringFlags(str, s, g, l, NULL);
Thomas Heller1b046642006-04-18 18:51:06 +00001979}
1980
1981#undef PyRun_SimpleString
1982PyAPI_FUNC(int)
1983PyRun_SimpleString(const char *s)
1984{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001985 return PyRun_SimpleStringFlags(s, NULL);
Thomas Heller1b046642006-04-18 18:51:06 +00001986}
1987
1988#undef Py_CompileString
1989PyAPI_FUNC(PyObject *)
1990Py_CompileString(const char *str, const char *p, int s)
1991{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001992 return Py_CompileStringFlags(str, p, s, NULL);
Thomas Heller1b046642006-04-18 18:51:06 +00001993}
1994
1995#undef PyRun_InteractiveOne
1996PyAPI_FUNC(int)
1997PyRun_InteractiveOne(FILE *f, const char *p)
1998{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00001999 return PyRun_InteractiveOneFlags(f, p, NULL);
Thomas Heller1b046642006-04-18 18:51:06 +00002000}
2001
2002#undef PyRun_InteractiveLoop
2003PyAPI_FUNC(int)
2004PyRun_InteractiveLoop(FILE *f, const char *p)
2005{
Antoine Pitrouc83ea132010-05-09 14:46:46 +00002006 return PyRun_InteractiveLoopFlags(f, p, NULL);
Thomas Heller1b046642006-04-18 18:51:06 +00002007}
2008
Anthony Baxterac6bd462006-04-13 02:06:09 +00002009#ifdef __cplusplus
2010}
2011#endif
2012