### Bug Summary

File: | Python/pythonrun.c
Location: | line 1563, column 13
Description: | Access to field 'ob_refcnt' results in a dereference of a null pointer (loaded from variable 'moduleName')

### Annotated Source Code

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 "symtable.h"
15 | #include "ast.h"
16 | #include "marshal.h"
17 | #include "osdefs.h"
18 |
19 | #ifdef HAVE_SIGNAL_H1
20 | #include <signal.h>
21 | #endif
22 |
23 | #ifdef MS_WINDOWS
24 | #include "malloc.h" /* for alloca */
25 | #endif
26 |
27 | #ifdef HAVE_LANGINFO_H1
28 | #include <locale.h>
29 | #include <langinfo.h>
30 | #endif
31 |
32 | #ifdef MS_WINDOWS
33 | #undef BYTEchar
34 | #include "windows.h"
35 | #define PATH_MAX1024 MAXPATHLEN1024
36 | #endif
37 |
38 | #ifndef Py_REF_DEBUG
39 | #define PRINT_TOTAL_REFS()fprintf(__stderrp, "[%" "l" "d refs]\n", _Py_GetRefTotal())
40 | #else /* Py_REF_DEBUG */
41 | #define PRINT_TOTAL_REFS()fprintf(__stderrp, "[%" "l" "d refs]\n", _Py_GetRefTotal()) fprintf(stderr__stderrp, \
42 | "[%" PY_FORMAT_SIZE_T"l" "d refs]\n", \
43 | _Py_GetRefTotal())
44 | #endif
45 |
46 | #ifdef __cplusplus
47 | extern "C" {
48 | #endif
49 |
50 | extern wchar_t *Py_GetPath(void);
51 |
52 | extern grammar _PyParser_Grammar; /* From graminit.c */
53 |
54 | /* Forward */
55 | static void initmain(void);
56 | static void initfsencoding(void);
57 | static void initsite(void);
58 | static int initstdio(void);
59 | static void flush_io(void);
60 | static PyObject *run_mod(mod_ty, const char *, PyObject *, PyObject *,
61 | PyCompilerFlags *, PyArena *);
62 | static PyObject *run_pyc_file(FILE *, const char *, PyObject *, PyObject *,
63 | PyCompilerFlags *);
64 | static void err_input(perrdetail *);
65 | static void initsigs(void);
66 | static void call_py_exitfuncs(void);
67 | static void wait_for_thread_shutdown(void);
68 | static void call_ll_exitfuncs(void);
69 | extern void _PyUnicode_Init_PyUnicodeUCS2_Init(void);
70 | extern void _PyUnicode_Fini_PyUnicodeUCS2_Fini(void);
71 | extern int _PyLong_Init(void);
72 | extern void PyLong_Fini(void);
73 |
74 | #ifdef WITH_THREAD1
75 | extern void _PyGILState_Init(PyInterpreterState *, PyThreadState *);
76 | extern void _PyGILState_Fini(void);
77 | #endif /* WITH_THREAD */
78 |
79 | int Py_DebugFlag; /* Needed by parser.c */
80 | int Py_VerboseFlag; /* Needed by import.c */
81 | int Py_QuietFlag; /* Needed by sysmodule.c */
82 | int Py_InteractiveFlag; /* Needed by Py_FdIsInteractive() below */
83 | int Py_InspectFlag; /* Needed to determine whether to exit at SystemError */
84 | int Py_NoSiteFlag; /* Suppress 'import site' */
85 | int Py_BytesWarningFlag; /* Warn on str(bytes) and str(buffer) */
86 | int Py_DontWriteBytecodeFlag; /* Suppress writing bytecode files (*.py[co]) */
87 | int Py_UseClassExceptionsFlag = 1; /* Needed by bltinmodule.c: deprecated */
88 | int Py_FrozenFlag; /* Needed by getpath.c */
89 | int Py_IgnoreEnvironmentFlag; /* e.g. PYTHONPATH, PYTHONHOME */
90 | int Py_NoUserSiteDirectory = 0; /* for -s and site.py */
91 | int Py_UnbufferedStdioFlag = 0; /* Unbuffered binary std{in,out,err} */
92 |
93 | /* PyModule_GetWarningsModule is no longer necessary as of 2.6
94 | since _warnings is builtin. This API should not be used. */
95 | PyObject *
96 | PyModule_GetWarningsModule(void)
97 | {
98 | return PyImport_ImportModule("warnings");
99 | }
100 |
101 | static int initialized = 0;
102 |
103 | /* API to access the initialized flag -- useful for esoteric use */
104 |
105 | int
106 | Py_IsInitialized(void)
107 | {
108 | return initialized;
109 | }
110 |
111 | /* Global initializations. Can be undone by Py_Finalize(). Don't
112 | call this twice without an intervening Py_Finalize() call. When
113 | initializations fail, a fatal error is issued and the function does
114 | not return. On return, the first thread and interpreter state have
115 | been created.
116 |
117 | Locking: you must hold the interpreter lock while calling this.
118 | (If the lock has not yet been initialized, that's equivalent to
119 | having the lock, but you cannot use multiple threads.)
120 |
121 | */
122 |
123 | static int
124 | add_flag(int flag, const char *envs)
125 | {
126 | int env = atoi(envs);
127 | if (flag < env)
128 | flag = env;
129 | if (flag < 1)
130 | flag = 1;
131 | return flag;
132 | }
133 |
134 | static char*
135 | get_codec_name(const char *encoding)
136 | {
137 | char *name_utf8, *name_str;
138 | PyObject *codec, *name = NULL((void *)0);
139 |
140 | codec = _PyCodec_Lookup(encoding);
141 | if (!codec)
142 | goto error;
143 |
144 | name = PyObject_GetAttrString(codec, "name");
145 | Py_CLEAR(codec)do { if (codec) { PyObject *_py_tmp = (PyObject *)(codec); (codec ) = ((void *)0); do { if (_Py_RefTotal-- , --((PyObject*)(_py_tmp ))->ob_refcnt != 0) { if (((PyObject*)_py_tmp)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c", 145, (PyObject *)(_py_tmp)); } else _Py_Dealloc((PyObject *)(_py_tmp)); } while (0); } } while (0);
146 | if (!name)
147 | goto error;
148 |
149 | name_utf8 = _PyUnicode_AsString(name);
150 | if (name == NULL((void *)0))
151 | goto error;
152 | name_str = strdup(name_utf8);
153 | Py_DECREF(name)do { if (_Py_RefTotal-- , --((PyObject*)(name))->ob_refcnt != 0) { if (((PyObject*)name)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 153, (PyObject *)(name)); } else _Py_Dealloc ((PyObject *)(name)); } while (0);
154 | if (name_str == NULL((void *)0)) {
155 | PyErr_NoMemory();
156 | return NULL((void *)0);
157 | }
158 | return name_str;
159 |
160 | error:
161 | Py_XDECREF(codec)do { if ((codec) == ((void *)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(codec))->ob_refcnt != 0) { if (((PyObject *)codec)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 161, (PyObject *)(codec)); } else _Py_Dealloc((PyObject *)( codec)); } while (0); } while (0);
162 | Py_XDECREF(name)do { if ((name) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(name))->ob_refcnt != 0) { if (((PyObject *)name)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 162, (PyObject *)(name)); } else _Py_Dealloc((PyObject *)(name )); } while (0); } while (0);
163 | return NULL((void *)0);
164 | }
165 |
166 | #if defined(HAVE_LANGINFO_H1) && defined(CODESET0)
167 | static char*
168 | get_codeset(void)
169 | {
170 | char* codeset = nl_langinfo(CODESET0);
171 | if (!codeset || codeset[0] == '\0') {
172 | PyErr_SetString(PyExc_ValueError, "CODESET is not set or empty");
173 | return NULL((void *)0);
174 | }
175 | return get_codec_name(codeset);
176 | }
177 | #endif
178 |
179 | void
180 | Py_InitializeEx(int install_sigs)
181 | {
182 | PyInterpreterState *interp;
183 | PyThreadState *tstate;
184 | PyObject *bimod, *sysmod, *pstderr;
185 | char *p;
186 | extern void _Py_ReadyTypes(void);
187 |
188 | if (initialized)
189 | return;
190 | initialized = 1;
191 |
192 | #if defined(HAVE_LANGINFO_H1) && defined(HAVE_SETLOCALE1)
193 | /* Set up the LC_CTYPE locale, so we can obtain
194 | the locale's charset without having to switch
195 | locales. */
196 | setlocale(LC_CTYPE2, "");
197 | #endif
198 |
199 | if ((p = Py_GETENV("PYTHONDEBUG")(Py_IgnoreEnvironmentFlag ? ((void *)0) : getenv("PYTHONDEBUG" ))) && *p != '\0')
200 | Py_DebugFlag = add_flag(Py_DebugFlag, p);
201 | if ((p = Py_GETENV("PYTHONVERBOSE")(Py_IgnoreEnvironmentFlag ? ((void *)0) : getenv("PYTHONVERBOSE" ))) && *p != '\0')
202 | Py_VerboseFlag = add_flag(Py_VerboseFlag, p);
203 | if ((p = Py_GETENV("PYTHONOPTIMIZE")(Py_IgnoreEnvironmentFlag ? ((void *)0) : getenv("PYTHONOPTIMIZE" ))) && *p != '\0')
204 | Py_OptimizeFlag = add_flag(Py_OptimizeFlag, p);
205 | if ((p = Py_GETENV("PYTHONDONTWRITEBYTECODE")(Py_IgnoreEnvironmentFlag ? ((void *)0) : getenv("PYTHONDONTWRITEBYTECODE" ))) && *p != '\0')
206 | Py_DontWriteBytecodeFlag = add_flag(Py_DontWriteBytecodeFlag, p);
207 |
208 | interp = PyInterpreterState_New();
209 | if (interp == NULL((void *)0))
210 | Py_FatalError("Py_Initialize: can't make first interpreter");
211 |
212 | tstate = PyThreadState_New(interp);
213 | if (tstate == NULL((void *)0))
214 | Py_FatalError("Py_Initialize: can't make first thread");
215 | (void) PyThreadState_Swap(tstate);
216 |
217 | #ifdef WITH_THREAD1
218 | /* We can't call _PyEval_FiniThreads() in Py_Finalize because
219 | destroying the GIL might fail when it is being referenced from
220 | another running thread (see issue #9901).
221 | Instead we destroy the previously created GIL here, which ensures
222 | that we can call Py_Initialize / Py_Finalize multiple times. */
223 | _PyEval_FiniThreads();
224 |
225 | /* Auto-thread-state API */
226 | _PyGILState_Init(interp, tstate);
227 | #endif /* WITH_THREAD */
228 |
229 | _Py_ReadyTypes();
230 |
231 | if (!_PyFrame_Init())
232 | Py_FatalError("Py_Initialize: can't init frames");
233 |
234 | if (!_PyLong_Init())
235 | Py_FatalError("Py_Initialize: can't init longs");
236 |
237 | if (!PyByteArray_Init())
238 | Py_FatalError("Py_Initialize: can't init bytearray");
239 |
240 | _PyFloat_Init();
241 |
242 | interp->modules = PyDict_New();
243 | if (interp->modules == NULL((void *)0))
244 | Py_FatalError("Py_Initialize: can't make modules dictionary");
245 | interp->modules_reloading = PyDict_New();
246 | if (interp->modules_reloading == NULL((void *)0))
247 | Py_FatalError("Py_Initialize: can't make modules_reloading dictionary");
248 |
249 | /* Init Unicode implementation; relies on the codec registry */
250 | _PyUnicode_Init_PyUnicodeUCS2_Init();
251 |
252 | bimod = _PyBuiltin_Init();
253 | if (bimod == NULL((void *)0))
254 | Py_FatalError("Py_Initialize: can't initialize builtins modules");
255 | _PyImport_FixupBuiltin(bimod, "builtins");
256 | interp->builtins = PyModule_GetDict(bimod);
257 | if (interp->builtins == NULL((void *)0))
258 | Py_FatalError("Py_Initialize: can't initialize builtins dict");
259 | Py_INCREF(interp->builtins)( _Py_RefTotal++ , ((PyObject*)(interp->builtins))->ob_refcnt ++);
260 |
261 | /* initialize builtin exceptions */
262 | _PyExc_Init();
263 |
264 | sysmod = _PySys_Init();
265 | if (sysmod == NULL((void *)0))
266 | Py_FatalError("Py_Initialize: can't initialize sys");
267 | interp->sysdict = PyModule_GetDict(sysmod);
268 | if (interp->sysdict == NULL((void *)0))
269 | Py_FatalError("Py_Initialize: can't initialize sys dict");
270 | Py_INCREF(interp->sysdict)( _Py_RefTotal++ , ((PyObject*)(interp->sysdict))->ob_refcnt ++);
271 | _PyImport_FixupBuiltin(sysmod, "sys");
272 | PySys_SetPath(Py_GetPath());
273 | PyDict_SetItemString(interp->sysdict, "modules",
274 | interp->modules);
275 |
276 | /* Set up a preliminary stderr printer until we have enough
277 | infrastructure for the io module in place. */
278 | pstderr = PyFile_NewStdPrinter(fileno(stderr__stderrp));
279 | if (pstderr == NULL((void *)0))
280 | Py_FatalError("Py_Initialize: can't set preliminary stderr");
281 | PySys_SetObject("stderr", pstderr);
282 | PySys_SetObject("__stderr__", pstderr);
283 | Py_DECREF(pstderr)do { if (_Py_RefTotal-- , --((PyObject*)(pstderr))->ob_refcnt != 0) { if (((PyObject*)pstderr)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 283, (PyObject *)(pstderr)); } else _Py_Dealloc ((PyObject *)(pstderr)); } while (0);
284 |
285 | _PyImport_Init();
286 |
287 | _PyImportHooks_Init();
288 |
289 | /* Initialize _warnings. */
290 | _PyWarnings_Init();
291 |
292 | _PyTime_Init();
293 |
294 | initfsencoding();
295 |
296 | if (install_sigs)
297 | initsigs(); /* Signal handling stuff, including initintr() */
298 |
299 | initmain(); /* Module __main__ */
300 | if (initstdio() < 0)
301 | Py_FatalError(
302 | "Py_Initialize: can't initialize sys standard streams");
303 |
304 | /* Initialize warnings. */
305 | if (PySys_HasWarnOptions()) {
306 | PyObject *warnings_module = PyImport_ImportModule("warnings");
307 | if (warnings_module == NULL((void *)0)) {
308 | fprintf(stderr__stderrp, "'import warnings' failed; traceback:\n");
309 | PyErr_Print();
310 | }
311 | Py_XDECREF(warnings_module)do { if ((warnings_module) == ((void *)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(warnings_module))->ob_refcnt != 0) { if (((PyObject*)warnings_module)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 311, (PyObject *)(warnings_module)); } else _Py_Dealloc((PyObject *)(warnings_module)); } while (0) ; } while (0);
312 | }
313 |
314 | if (!Py_NoSiteFlag)
315 | initsite(); /* Module site */
316 | }
317 |
318 | void
319 | Py_Initialize(void)
320 | {
321 | Py_InitializeEx(1);
322 | }
323 |
324 |
325 | #ifdef COUNT_ALLOCS
326 | extern void dump_counts(FILE*);
327 | #endif
328 |
329 | /* Flush stdout and stderr */
330 |
331 | static void
332 | flush_std_files(void)
333 | {
334 | PyObject *fout = PySys_GetObject("stdout");
335 | PyObject *ferr = PySys_GetObject("stderr");
336 | PyObject *tmp;
337 |
338 | if (fout != NULL((void *)0) && fout != Py_None(&_Py_NoneStruct)) {
339 | tmp = PyObject_CallMethod(fout, "flush", "");
340 | if (tmp == NULL((void *)0))
341 | PyErr_WriteUnraisable(fout);
342 | else
343 | Py_DECREF(tmp)do { if (_Py_RefTotal-- , --((PyObject*)(tmp))->ob_refcnt != 0) { if (((PyObject*)tmp)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 343, (PyObject *)(tmp)); } else _Py_Dealloc ((PyObject *)(tmp)); } while (0);
344 | }
345 |
346 | if (ferr != NULL((void *)0) && ferr != Py_None(&_Py_NoneStruct)) {
347 | tmp = PyObject_CallMethod(ferr, "flush", "");
348 | if (tmp == NULL((void *)0))
349 | PyErr_Clear();
350 | else
351 | Py_DECREF(tmp)do { if (_Py_RefTotal-- , --((PyObject*)(tmp))->ob_refcnt != 0) { if (((PyObject*)tmp)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 351, (PyObject *)(tmp)); } else _Py_Dealloc ((PyObject *)(tmp)); } while (0);
352 | }
353 | }
354 |
355 | /* Undo the effect of Py_Initialize().
356 |
357 | Beware: if multiple interpreter and/or thread states exist, these
358 | are not wiped out; only the current thread and interpreter state
359 | are deleted. But since everything else is deleted, those other
360 | interpreter and thread states should no longer be used.
361 |
362 | (XXX We should do better, e.g. wipe out all interpreters and
363 | threads.)
364 |
365 | Locking: as above.
366 |
367 | */
368 |
369 | void
370 | Py_Finalize(void)
371 | {
372 | PyInterpreterState *interp;
373 | PyThreadState *tstate;
374 |
375 | if (!initialized)
376 | return;
377 |
378 | wait_for_thread_shutdown();
379 |
380 | /* The interpreter is still entirely intact at this point, and the
381 | * exit funcs may be relying on that. In particular, if some thread
382 | * or exit func is still waiting to do an import, the import machinery
383 | * expects Py_IsInitialized() to return true. So don't say the
384 | * interpreter is uninitialized until after the exit funcs have run.
385 | * Note that Threading.py uses an exit func to do a join on all the
386 | * threads created thru it, so this also protects pending imports in
387 | * the threads created via Threading.
388 | */
389 | call_py_exitfuncs();
390 | initialized = 0;
391 |
392 | /* Flush stdout+stderr */
393 | flush_std_files();
394 |
395 | /* Get current thread state and interpreter pointer */
396 | tstate = PyThreadState_GET()PyThreadState_Get();
397 | interp = tstate->interp;
398 |
399 | /* Disable signal handling */
400 | PyOS_FiniInterrupts();
401 |
402 | /* Clear type lookup cache */
403 | PyType_ClearCache();
404 |
405 | /* Collect garbage. This may call finalizers; it's nice to call these
406 | * before all modules are destroyed.
407 | * XXX If a __del__ or weakref callback is triggered here, and tries to
408 | * XXX import a module, bad things can happen, because Python no
409 | * XXX longer believes it's initialized.
410 | * XXX Fatal Python error: Interpreter not initialized (version mismatch?)
411 | * XXX is easy to provoke that way. I've also seen, e.g.,
412 | * XXX Exception exceptions.ImportError: 'No module named sha'
413 | * XXX in <function callback at 0x008F5718> ignored
414 | * XXX but I'm unclear on exactly how that one happens. In any case,
415 | * XXX I haven't seen a real-life report of either of these.
416 | */
417 | PyGC_Collect();
418 | #ifdef COUNT_ALLOCS
419 | /* With COUNT_ALLOCS, it helps to run GC multiple times:
420 | each collection might release some types from the type
421 | list, so they become garbage. */
422 | while (PyGC_Collect() > 0)
423 | /* nothing */;
424 | #endif
425 | /* We run this while most interpreter state is still alive, so that
426 | debug information can be printed out */
427 | _PyGC_Fini();
428 |
429 | /* Destroy all modules */
430 | PyImport_Cleanup();
431 |
432 | /* Flush stdout+stderr (again, in case more was printed) */
433 | flush_std_files();
434 |
435 | /* Collect final garbage. This disposes of cycles created by
436 | * new-style class definitions, for example.
437 | * XXX This is disabled because it caused too many problems. If
438 | * XXX a __del__ or weakref callback triggers here, Python code has
439 | * XXX a hard time running, because even the sys module has been
440 | * XXX cleared out (sys.stdout is gone, sys.excepthook is gone, etc).
441 | * XXX One symptom is a sequence of information-free messages
442 | * XXX coming from threads (if a __del__ or callback is invoked,
443 | * XXX other threads can execute too, and any exception they encounter
444 | * XXX triggers a comedy of errors as subsystem after subsystem
445 | * XXX fails to find what it *expects* to find in sys to help report
446 | * XXX the exception and consequent unexpected failures). I've also
447 | * XXX seen segfaults then, after adding print statements to the
448 | * XXX Python code getting called.
449 | */
450 | #if 0
451 | PyGC_Collect();
452 | #endif
453 |
454 | /* Destroy the database used by _PyImport_{Fixup,Find}Extension */
455 | _PyImport_Fini();
456 |
457 | /* Debugging stuff */
458 | #ifdef COUNT_ALLOCS
459 | dump_counts(stdout__stdoutp);
460 | #endif
461 |
462 | PRINT_TOTAL_REFS()fprintf(__stderrp, "[%" "l" "d refs]\n", _Py_GetRefTotal());
463 |
464 | #ifdef Py_TRACE_REFS
465 | /* Display all objects still alive -- this can invoke arbitrary
466 | * __repr__ overrides, so requires a mostly-intact interpreter.
467 | * Alas, a lot of stuff may still be alive now that will be cleaned
468 | * up later.
469 | */
470 | if (Py_GETENV("PYTHONDUMPREFS")(Py_IgnoreEnvironmentFlag ? ((void *)0) : getenv("PYTHONDUMPREFS" )))
471 | _Py_PrintReferences(stderr__stderrp);
472 | #endif /* Py_TRACE_REFS */
473 |
474 | /* Clear interpreter state */
475 | PyInterpreterState_Clear(interp);
476 |
477 | /* Now we decref the exception classes. After this point nothing
478 | can raise an exception. That's okay, because each Fini() method
479 | below has been checked to make sure no exceptions are ever
480 | raised.
481 | */
482 |
483 | _PyExc_Fini();
484 |
485 | /* Cleanup auto-thread-state */
486 | #ifdef WITH_THREAD1
487 | _PyGILState_Fini();
488 | #endif /* WITH_THREAD */
489 |
490 | /* Delete current thread */
491 | PyThreadState_Swap(NULL((void *)0));
492 | PyInterpreterState_Delete(interp);
493 |
494 | /* Sundry finalizers */
495 | PyMethod_Fini();
496 | PyFrame_Fini();
497 | PyCFunction_Fini();
498 | PyTuple_Fini();
499 | PyList_Fini();
500 | PySet_Fini();
501 | PyBytes_Fini();
502 | PyByteArray_Fini();
503 | PyLong_Fini();
504 | PyFloat_Fini();
505 | PyDict_Fini();
506 |
507 | /* Cleanup Unicode implementation */
508 | _PyUnicode_Fini_PyUnicodeUCS2_Fini();
509 |
510 | /* reset file system default encoding */
511 | if (!Py_HasFileSystemDefaultEncoding && Py_FileSystemDefaultEncoding) {
512 | free((char*)Py_FileSystemDefaultEncoding);
513 | Py_FileSystemDefaultEncoding = NULL((void *)0);
514 | }
515 |
516 | /* XXX Still allocated:
517 | - various static ad-hoc pointers to interned strings
518 | - int and float free list blocks
519 | - whatever various modules and libraries allocate
520 | */
521 |
522 | PyGrammar_RemoveAccelerators(&_PyParser_Grammar);
523 |
524 | #ifdef Py_TRACE_REFS
525 | /* Display addresses (& refcnts) of all objects still alive.
526 | * An address can be used to find the repr of the object, printed
527 | * above by _Py_PrintReferences.
528 | */
529 | if (Py_GETENV("PYTHONDUMPREFS")(Py_IgnoreEnvironmentFlag ? ((void *)0) : getenv("PYTHONDUMPREFS" )))
530 | _Py_PrintReferenceAddresses(stderr__stderrp);
531 | #endif /* Py_TRACE_REFS */
532 | #ifdef PYMALLOC_DEBUG
533 | if (Py_GETENV("PYTHONMALLOCSTATS")(Py_IgnoreEnvironmentFlag ? ((void *)0) : getenv("PYTHONMALLOCSTATS" )))
534 | _PyObject_DebugMallocStats();
535 | #endif
536 |
537 | call_ll_exitfuncs();
538 | }
539 |
540 | /* Create and initialize a new interpreter and thread, and return the
541 | new thread. This requires that Py_Initialize() has been called
542 | first.
543 |
544 | Unsuccessful initialization yields a NULL pointer. Note that *no*
545 | exception information is available even in this case -- the
546 | exception information is held in the thread, and there is no
547 | thread.
548 |
549 | Locking: as above.
550 |
551 | */
552 |
553 | PyThreadState *
554 | Py_NewInterpreter(void)
555 | {
556 | PyInterpreterState *interp;
557 | PyThreadState *tstate, *save_tstate;
558 | PyObject *bimod, *sysmod;
559 |
560 | if (!initialized)
561 | Py_FatalError("Py_NewInterpreter: call Py_Initialize first");
562 |
563 | interp = PyInterpreterState_New();
564 | if (interp == NULL((void *)0))
565 | return NULL((void *)0);
566 |
567 | tstate = PyThreadState_New(interp);
568 | if (tstate == NULL((void *)0)) {
569 | PyInterpreterState_Delete(interp);
570 | return NULL((void *)0);
571 | }
572 |
573 | save_tstate = PyThreadState_Swap(tstate);
574 |
575 | /* XXX The following is lax in error checking */
576 |
577 | interp->modules = PyDict_New();
578 | interp->modules_reloading = PyDict_New();
579 |
580 | bimod = _PyImport_FindBuiltin("builtins");
581 | if (bimod != NULL((void *)0)) {
582 | interp->builtins = PyModule_GetDict(bimod);
583 | if (interp->builtins == NULL((void *)0))
584 | goto handle_error;
585 | Py_INCREF(interp->builtins)( _Py_RefTotal++ , ((PyObject*)(interp->builtins))->ob_refcnt ++);
586 | }
587 |
588 | /* initialize builtin exceptions */
589 | _PyExc_Init();
590 |
591 | sysmod = _PyImport_FindBuiltin("sys");
592 | if (bimod != NULL((void *)0) && sysmod != NULL((void *)0)) {
593 | PyObject *pstderr;
594 | interp->sysdict = PyModule_GetDict(sysmod);
595 | if (interp->sysdict == NULL((void *)0))
596 | goto handle_error;
597 | Py_INCREF(interp->sysdict)( _Py_RefTotal++ , ((PyObject*)(interp->sysdict))->ob_refcnt ++);
598 | PySys_SetPath(Py_GetPath());
599 | PyDict_SetItemString(interp->sysdict, "modules",
600 | interp->modules);
601 | /* Set up a preliminary stderr printer until we have enough
602 | infrastructure for the io module in place. */
603 | pstderr = PyFile_NewStdPrinter(fileno(stderr__stderrp));
604 | if (pstderr == NULL((void *)0))
605 | Py_FatalError("Py_Initialize: can't set preliminary stderr");
606 | PySys_SetObject("stderr", pstderr);
607 | PySys_SetObject("__stderr__", pstderr);
608 | Py_DECREF(pstderr)do { if (_Py_RefTotal-- , --((PyObject*)(pstderr))->ob_refcnt != 0) { if (((PyObject*)pstderr)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 608, (PyObject *)(pstderr)); } else _Py_Dealloc ((PyObject *)(pstderr)); } while (0);
609 |
610 | _PyImportHooks_Init();
611 | if (initstdio() < 0)
612 | Py_FatalError(
613 | "Py_Initialize: can't initialize sys standard streams");
614 | initmain();
615 | if (!Py_NoSiteFlag)
616 | initsite();
617 | }
618 |
619 | if (!PyErr_Occurred())
620 | return tstate;
621 |
622 | handle_error:
623 | /* Oops, it didn't work. Undo it all. */
624 |
625 | PyErr_Print();
626 | PyThreadState_Clear(tstate);
627 | PyThreadState_Swap(save_tstate);
628 | PyThreadState_Delete(tstate);
629 | PyInterpreterState_Delete(interp);
630 |
631 | return NULL((void *)0);
632 | }
633 |
634 | /* Delete an interpreter and its last thread. This requires that the
635 | given thread state is current, that the thread has no remaining
636 | frames, and that it is its interpreter's only remaining thread.
637 | It is a fatal error to violate these constraints.
638 |
639 | (Py_Finalize() doesn't have these constraints -- it zaps
640 | everything, regardless.)
641 |
642 | Locking: as above.
643 |
644 | */
645 |
646 | void
647 | Py_EndInterpreter(PyThreadState *tstate)
648 | {
649 | PyInterpreterState *interp = tstate->interp;
650 |
651 | if (tstate != PyThreadState_GET()PyThreadState_Get())
652 | Py_FatalError("Py_EndInterpreter: thread is not current");
653 | if (tstate->frame != NULL((void *)0))
654 | Py_FatalError("Py_EndInterpreter: thread still has a frame");
655 | if (tstate != interp->tstate_head || tstate->next != NULL((void *)0))
656 | Py_FatalError("Py_EndInterpreter: not the last thread");
657 |
658 | PyImport_Cleanup();
659 | PyInterpreterState_Clear(interp);
660 | PyThreadState_Swap(NULL((void *)0));
661 | PyInterpreterState_Delete(interp);
662 | }
663 |
664 | static wchar_t *progname = L"python";
665 |
666 | void
667 | Py_SetProgramName(wchar_t *pn)
668 | {
669 | if (pn && *pn)
670 | progname = pn;
671 | }
672 |
673 | wchar_t *
674 | Py_GetProgramName(void)
675 | {
676 | return progname;
677 | }
678 |
679 | static wchar_t *default_home = NULL((void *)0);
680 | static wchar_t env_home[PATH_MAX1024+1];
681 |
682 | void
683 | Py_SetPythonHome(wchar_t *home)
684 | {
685 | default_home = home;
686 | }
687 |
688 | wchar_t *
689 | Py_GetPythonHome(void)
690 | {
691 | wchar_t *home = default_home;
692 | if (home == NULL((void *)0) && !Py_IgnoreEnvironmentFlag) {
693 | char* chome = Py_GETENV("PYTHONHOME")(Py_IgnoreEnvironmentFlag ? ((void *)0) : getenv("PYTHONHOME" ));
694 | if (chome) {
695 | size_t r = mbstowcs(env_home, chome, PATH_MAX1024+1);
696 | if (r != (size_t)-1 && r <= PATH_MAX1024)
697 | home = env_home;
698 | }
699 |
700 | }
701 | return home;
702 | }
703 |
704 | /* Create __main__ module */
705 |
706 | static void
707 | initmain(void)
708 | {
709 | PyObject *m, *d;
710 | m = PyImport_AddModule("__main__");
711 | if (m == NULL((void *)0))
712 | Py_FatalError("can't create __main__ module");
713 | d = PyModule_GetDict(m);
714 | if (PyDict_GetItemString(d, "__builtins__") == NULL((void *)0)) {
715 | PyObject *bimod = PyImport_ImportModule("builtins");
716 | if (bimod == NULL((void *)0) ||
717 | PyDict_SetItemString(d, "__builtins__", bimod) != 0)
718 | Py_FatalError("can't add __builtins__ to __main__");
719 | Py_DECREF(bimod)do { if (_Py_RefTotal-- , --((PyObject*)(bimod))->ob_refcnt != 0) { if (((PyObject*)bimod)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 719, (PyObject *)(bimod)); } else _Py_Dealloc ((PyObject *)(bimod)); } while (0);
720 | }
721 | }
722 |
723 | static void
724 | initfsencoding(void)
725 | {
726 | PyObject *codec;
727 | #if defined(HAVE_LANGINFO_H1) && defined(CODESET0)
728 | char *codeset = NULL((void *)0);
729 |
730 | if (Py_FileSystemDefaultEncoding == NULL((void *)0)) {
731 | /* On Unix, set the file system encoding according to the
732 | user's preference, if the CODESET names a well-known
733 | Python codec, and Py_FileSystemDefaultEncoding isn't
734 | initialized by other means. */
735 | codeset = get_codeset();
736 | if (codeset == NULL((void *)0))
737 | Py_FatalError("Py_Initialize: Unable to get the locale encoding");
738 |
739 | Py_FileSystemDefaultEncoding = codeset;
740 | Py_HasFileSystemDefaultEncoding = 0;
741 | return;
742 | }
743 | #endif
744 |
745 | /* the encoding is mbcs, utf-8 or ascii */
746 | codec = _PyCodec_Lookup(Py_FileSystemDefaultEncoding);
747 | if (!codec) {
748 | /* Such error can only occurs in critical situations: no more
749 | * memory, import a module of the standard library failed,
750 | * etc. */
751 | Py_FatalError("Py_Initialize: unable to load the file system codec");
752 | } else {
753 | Py_DECREF(codec)do { if (_Py_RefTotal-- , --((PyObject*)(codec))->ob_refcnt != 0) { if (((PyObject*)codec)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 753, (PyObject *)(codec)); } else _Py_Dealloc ((PyObject *)(codec)); } while (0);
754 | }
755 | }
756 |
757 | /* Import the site module (not into __main__ though) */
758 |
759 | static void
760 | initsite(void)
761 | {
762 | PyObject *m;
763 | m = PyImport_ImportModule("site");
764 | if (m == NULL((void *)0)) {
765 | PyErr_Print();
766 | Py_Finalize();
767 | exit(1);
768 | }
769 | else {
770 | Py_DECREF(m)do { if (_Py_RefTotal-- , --((PyObject*)(m))->ob_refcnt != 0) { if (((PyObject*)m)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 770, (PyObject *)(m)); } else _Py_Dealloc ((PyObject *)(m)); } while (0);
771 | }
772 | }
773 |
774 | static PyObject*
775 | create_stdio(PyObject* io,
776 | int fd, int write_mode, char* name,
777 | char* encoding, char* errors)
778 | {
779 | PyObject *buf = NULL((void *)0), *stream = NULL((void *)0), *text = NULL((void *)0), *raw = NULL((void *)0), *res;
780 | const char* mode;
781 | PyObject *line_buffering;
782 | int buffering, isatty;
783 |
784 | /* stdin is always opened in buffered mode, first because it shouldn't
785 | make a difference in common use cases, second because TextIOWrapper
786 | depends on the presence of a read1() method which only exists on
787 | buffered streams.
788 | */
789 | if (Py_UnbufferedStdioFlag && write_mode)
790 | buffering = 0;
791 | else
792 | buffering = -1;
793 | if (write_mode)
794 | mode = "wb";
795 | else
796 | mode = "rb";
797 | buf = PyObject_CallMethod(io, "open", "isiOOOi",
798 | fd, mode, buffering,
799 | Py_None(&_Py_NoneStruct), Py_None(&_Py_NoneStruct), Py_None(&_Py_NoneStruct), 0);
800 | if (buf == NULL((void *)0))
801 | goto error;
802 |
803 | if (buffering) {
804 | raw = PyObject_GetAttrString(buf, "raw");
805 | if (raw == NULL((void *)0))
806 | goto error;
807 | }
808 | else {
809 | raw = buf;
810 | Py_INCREF(raw)( _Py_RefTotal++ , ((PyObject*)(raw))->ob_refcnt++);
811 | }
812 |
813 | text = PyUnicode_FromStringPyUnicodeUCS2_FromString(name);
814 | if (text == NULL((void *)0) || PyObject_SetAttrString(raw, "name", text) < 0)
815 | goto error;
816 | res = PyObject_CallMethod(raw, "isatty", "");
817 | if (res == NULL((void *)0))
818 | goto error;
819 | isatty = PyObject_IsTrue(res);
820 | Py_DECREF(res)do { if (_Py_RefTotal-- , --((PyObject*)(res))->ob_refcnt != 0) { if (((PyObject*)res)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 820, (PyObject *)(res)); } else _Py_Dealloc ((PyObject *)(res)); } while (0);
821 | if (isatty == -1)
822 | goto error;
823 | if (isatty || Py_UnbufferedStdioFlag)
824 | line_buffering = Py_True((PyObject *) &_Py_TrueStruct);
825 | else
826 | line_buffering = Py_False((PyObject *) &_Py_FalseStruct);
827 |
828 | Py_CLEAR(raw)do { if (raw) { PyObject *_py_tmp = (PyObject *)(raw); (raw) = ((void *)0); do { if (_Py_RefTotal-- , --((PyObject*)(_py_tmp ))->ob_refcnt != 0) { if (((PyObject*)_py_tmp)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c", 828, (PyObject *)(_py_tmp)); } else _Py_Dealloc((PyObject *)(_py_tmp)); } while (0); } } while (0);
829 | Py_CLEAR(text)do { if (text) { PyObject *_py_tmp = (PyObject *)(text); (text ) = ((void *)0); do { if (_Py_RefTotal-- , --((PyObject*)(_py_tmp ))->ob_refcnt != 0) { if (((PyObject*)_py_tmp)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c", 829, (PyObject *)(_py_tmp)); } else _Py_Dealloc((PyObject *)(_py_tmp)); } while (0); } } while (0);
830 |
831 | stream = PyObject_CallMethod(io, "TextIOWrapper", "OsssO",
832 | buf, encoding, errors,
833 | "\n", line_buffering);
834 | Py_CLEAR(buf)do { if (buf) { PyObject *_py_tmp = (PyObject *)(buf); (buf) = ((void *)0); do { if (_Py_RefTotal-- , --((PyObject*)(_py_tmp ))->ob_refcnt != 0) { if (((PyObject*)_py_tmp)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c", 834, (PyObject *)(_py_tmp)); } else _Py_Dealloc((PyObject *)(_py_tmp)); } while (0); } } while (0);
835 | if (stream == NULL((void *)0))
836 | goto error;
837 |
838 | if (write_mode)
839 | mode = "w";
840 | else
841 | mode = "r";
842 | text = PyUnicode_FromStringPyUnicodeUCS2_FromString(mode);
843 | if (!text || PyObject_SetAttrString(stream, "mode", text) < 0)
844 | goto error;
845 | Py_CLEAR(text)do { if (text) { PyObject *_py_tmp = (PyObject *)(text); (text ) = ((void *)0); do { if (_Py_RefTotal-- , --((PyObject*)(_py_tmp ))->ob_refcnt != 0) { if (((PyObject*)_py_tmp)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c", 845, (PyObject *)(_py_tmp)); } else _Py_Dealloc((PyObject *)(_py_tmp)); } while (0); } } while (0);
846 | return stream;
847 |
848 | error:
849 | Py_XDECREF(buf)do { if ((buf) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(buf))->ob_refcnt != 0) { if (((PyObject* )buf)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 849, (PyObject *)(buf)); } else _Py_Dealloc((PyObject *)(buf )); } while (0); } while (0);
850 | Py_XDECREF(stream)do { if ((stream) == ((void *)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(stream))->ob_refcnt != 0) { if (((PyObject *)stream)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 850, (PyObject *)(stream)); } else _Py_Dealloc((PyObject *) (stream)); } while (0); } while (0);
851 | Py_XDECREF(text)do { if ((text) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(text))->ob_refcnt != 0) { if (((PyObject *)text)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 851, (PyObject *)(text)); } else _Py_Dealloc((PyObject *)(text )); } while (0); } while (0);
852 | Py_XDECREF(raw)do { if ((raw) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(raw))->ob_refcnt != 0) { if (((PyObject* )raw)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 852, (PyObject *)(raw)); } else _Py_Dealloc((PyObject *)(raw )); } while (0); } while (0);
853 | return NULL((void *)0);
854 | }
855 |
856 | /* Initialize sys.stdin, stdout, stderr and builtins.open */
857 | static int
858 | initstdio(void)
859 | {
860 | PyObject *iomod = NULL((void *)0), *wrapper;
861 | PyObject *bimod = NULL((void *)0);
862 | PyObject *m;
863 | PyObject *std = NULL((void *)0);
864 | int status = 0, fd;
865 | PyObject * encoding_attr;
866 | char *encoding = NULL((void *)0), *errors;
867 |
868 | /* Hack to avoid a nasty recursion issue when Python is invoked
869 | in verbose mode: pre-import the Latin-1 and UTF-8 codecs */
870 | if ((m = PyImport_ImportModule("encodings.utf_8")) == NULL((void *)0)) {
871 | goto error;
872 | }
873 | Py_DECREF(m)do { if (_Py_RefTotal-- , --((PyObject*)(m))->ob_refcnt != 0) { if (((PyObject*)m)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 873, (PyObject *)(m)); } else _Py_Dealloc ((PyObject *)(m)); } while (0);
874 |
875 | if (!(m = PyImport_ImportModule("encodings.latin_1"))) {
876 | goto error;
877 | }
878 | Py_DECREF(m)do { if (_Py_RefTotal-- , --((PyObject*)(m))->ob_refcnt != 0) { if (((PyObject*)m)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 878, (PyObject *)(m)); } else _Py_Dealloc ((PyObject *)(m)); } while (0);
879 |
880 | if (!(bimod = PyImport_ImportModule("builtins"))) {
881 | goto error;
882 | }
883 |
884 | if (!(iomod = PyImport_ImportModule("io"))) {
885 | goto error;
886 | }
887 | if (!(wrapper = PyObject_GetAttrString(iomod, "OpenWrapper"))) {
888 | goto error;
889 | }
890 |
891 | /* Set builtins.open */
892 | if (PyObject_SetAttrString(bimod, "open", wrapper) == -1) {
893 | Py_DECREF(wrapper)do { if (_Py_RefTotal-- , --((PyObject*)(wrapper))->ob_refcnt != 0) { if (((PyObject*)wrapper)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 893, (PyObject *)(wrapper)); } else _Py_Dealloc ((PyObject *)(wrapper)); } while (0);
894 | goto error;
895 | }
896 | Py_DECREF(wrapper)do { if (_Py_RefTotal-- , --((PyObject*)(wrapper))->ob_refcnt != 0) { if (((PyObject*)wrapper)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 896, (PyObject *)(wrapper)); } else _Py_Dealloc ((PyObject *)(wrapper)); } while (0);
897 |
898 | encoding = Py_GETENV("PYTHONIOENCODING")(Py_IgnoreEnvironmentFlag ? ((void *)0) : getenv("PYTHONIOENCODING" ));
899 | errors = NULL((void *)0);
900 | if (encoding) {
901 | encoding = strdup(encoding);
902 | errors = strchr(encoding, ':');
903 | if (errors) {
904 | *errors = '\0';
905 | errors++;
906 | }
907 | }
908 |
909 | /* Set sys.stdin */
910 | fd = fileno(stdin__stdinp);
911 | /* Under some conditions stdin, stdout and stderr may not be connected
912 | * and fileno() may point to an invalid file descriptor. For example
913 | * GUI apps don't have valid standard streams by default.
914 | */
915 | if (fd < 0) {
916 | #ifdef MS_WINDOWS
917 | std = Py_None(&_Py_NoneStruct);
918 | Py_INCREF(std)( _Py_RefTotal++ , ((PyObject*)(std))->ob_refcnt++);
919 | #else
920 | goto error;
921 | #endif
922 | }
923 | else {
924 | std = create_stdio(iomod, fd, 0, "<stdin>", encoding, errors);
925 | if (std == NULL((void *)0))
926 | goto error;
927 | } /* if (fd < 0) */
928 | PySys_SetObject("__stdin__", std);
929 | PySys_SetObject("stdin", std);
930 | Py_DECREF(std)do { if (_Py_RefTotal-- , --((PyObject*)(std))->ob_refcnt != 0) { if (((PyObject*)std)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 930, (PyObject *)(std)); } else _Py_Dealloc ((PyObject *)(std)); } while (0);
931 |
932 | /* Set sys.stdout */
933 | fd = fileno(stdout__stdoutp);
934 | if (fd < 0) {
935 | #ifdef MS_WINDOWS
936 | std = Py_None(&_Py_NoneStruct);
937 | Py_INCREF(std)( _Py_RefTotal++ , ((PyObject*)(std))->ob_refcnt++);
938 | #else
939 | goto error;
940 | #endif
941 | }
942 | else {
943 | std = create_stdio(iomod, fd, 1, "<stdout>", encoding, errors);
944 | if (std == NULL((void *)0))
945 | goto error;
946 | } /* if (fd < 0) */
947 | PySys_SetObject("__stdout__", std);
948 | PySys_SetObject("stdout", std);
949 | Py_DECREF(std)do { if (_Py_RefTotal-- , --((PyObject*)(std))->ob_refcnt != 0) { if (((PyObject*)std)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 949, (PyObject *)(std)); } else _Py_Dealloc ((PyObject *)(std)); } while (0);
950 |
951 | #if 1 /* Disable this if you have trouble debugging bootstrap stuff */
952 | /* Set sys.stderr, replaces the preliminary stderr */
953 | fd = fileno(stderr__stderrp);
954 | if (fd < 0) {
955 | #ifdef MS_WINDOWS
956 | std = Py_None(&_Py_NoneStruct);
957 | Py_INCREF(std)( _Py_RefTotal++ , ((PyObject*)(std))->ob_refcnt++);
958 | #else
959 | goto error;
960 | #endif
961 | }
962 | else {
963 | std = create_stdio(iomod, fd, 1, "<stderr>", encoding, "backslashreplace");
964 | if (std == NULL((void *)0))
965 | goto error;
966 | } /* if (fd < 0) */
967 |
968 | /* Same as hack above, pre-import stderr's codec to avoid recursion
969 | when import.c tries to write to stderr in verbose mode. */
970 | encoding_attr = PyObject_GetAttrString(std, "encoding");
971 | if (encoding_attr != NULL((void *)0)) {
972 | const char * encoding;
973 | encoding = _PyUnicode_AsString(encoding_attr);
974 | if (encoding != NULL((void *)0)) {
975 | _PyCodec_Lookup(encoding);
976 | }
977 | Py_DECREF(encoding_attr)do { if (_Py_RefTotal-- , --((PyObject*)(encoding_attr))-> ob_refcnt != 0) { if (((PyObject*)encoding_attr)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c", 977, (PyObject *)(encoding_attr)); } else _Py_Dealloc((PyObject *)(encoding_attr )); } while (0);
978 | }
979 | PyErr_Clear(); /* Not a fatal error if codec isn't available */
980 |
981 | PySys_SetObject("__stderr__", std);
982 | PySys_SetObject("stderr", std);
983 | Py_DECREF(std)do { if (_Py_RefTotal-- , --((PyObject*)(std))->ob_refcnt != 0) { if (((PyObject*)std)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 983, (PyObject *)(std)); } else _Py_Dealloc ((PyObject *)(std)); } while (0);
984 | #endif
985 |
986 | if (0) {
987 | error:
988 | status = -1;
989 | }
990 |
991 | if (encoding)
992 | free(encoding);
993 | Py_XDECREF(bimod)do { if ((bimod) == ((void *)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(bimod))->ob_refcnt != 0) { if (((PyObject *)bimod)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 993, (PyObject *)(bimod)); } else _Py_Dealloc((PyObject *)( bimod)); } while (0); } while (0);
994 | Py_XDECREF(iomod)do { if ((iomod) == ((void *)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(iomod))->ob_refcnt != 0) { if (((PyObject *)iomod)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 994, (PyObject *)(iomod)); } else _Py_Dealloc((PyObject *)( iomod)); } while (0); } while (0);
995 | return status;
996 | }
997 |
998 | /* Parse input from a file and execute it */
999 |
1000 | int
1001 | PyRun_AnyFileExFlags(FILE *fp, const char *filename, int closeit,
1002 | PyCompilerFlags *flags)
1003 | {
1004 | if (filename == NULL((void *)0))
1005 | filename = "???";
1006 | if (Py_FdIsInteractive(fp, filename)) {
1007 | int err = PyRun_InteractiveLoopFlags(fp, filename, flags);
1008 | if (closeit)
1009 | fclose(fp);
1010 | return err;
1011 | }
1012 | else
1013 | return PyRun_SimpleFileExFlags(fp, filename, closeit, flags);
1014 | }
1015 |
1016 | int
1017 | PyRun_InteractiveLoopFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
1018 | {
1019 | PyObject *v;
1020 | int ret;
1021 | PyCompilerFlags local_flags;
1022 |
1023 | if (flags == NULL((void *)0)) {
1024 | flags = &local_flags;
1025 | local_flags.cf_flags = 0;
1026 | }
1027 | v = PySys_GetObject("ps1");
1028 | if (v == NULL((void *)0)) {
1029 | PySys_SetObject("ps1", v = PyUnicode_FromStringPyUnicodeUCS2_FromString(">>> "));
1030 | Py_XDECREF(v)do { if ((v) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt != 0) { if (((PyObject*)v)-> ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c", 1030 , (PyObject *)(v)); } else _Py_Dealloc((PyObject *)(v)); } while (0); } while (0);
1031 | }
1032 | v = PySys_GetObject("ps2");
1033 | if (v == NULL((void *)0)) {
1034 | PySys_SetObject("ps2", v = PyUnicode_FromStringPyUnicodeUCS2_FromString("... "));
1035 | Py_XDECREF(v)do { if ((v) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt != 0) { if (((PyObject*)v)-> ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c", 1035 , (PyObject *)(v)); } else _Py_Dealloc((PyObject *)(v)); } while (0); } while (0);
1036 | }
1037 | for (;;) {
1038 | ret = PyRun_InteractiveOneFlags(fp, filename, flags);
1039 | PRINT_TOTAL_REFS()fprintf(__stderrp, "[%" "l" "d refs]\n", _Py_GetRefTotal());
1040 | if (ret == E_EOF11)
1041 | return 0;
1042 | /*
1043 | if (ret == E_NOMEM)
1044 | return -1;
1045 | */
1046 | }
1047 | }
1048 |
1049 | /* compute parser flags based on compiler flags */
1050 | static int PARSER_FLAGS(PyCompilerFlags *flags)
1051 | {
1052 | int parser_flags = 0;
1053 | if (!flags)
1054 | return 0;
1055 | if (flags->cf_flags & PyCF_DONT_IMPLY_DEDENT0x0200)
1056 | parser_flags |= PyPARSE_DONT_IMPLY_DEDENT0x0002;
1057 | if (flags->cf_flags & PyCF_IGNORE_COOKIE0x0800)
1058 | parser_flags |= PyPARSE_IGNORE_COOKIE0x0010;
1059 | if (flags->cf_flags & CO_FUTURE_BARRY_AS_BDFL0x40000)
1060 | parser_flags |= PyPARSE_BARRY_AS_BDFL0x0020;
1061 | return parser_flags;
1062 | }
1063 |
1064 | #if 0
1065 | /* Keep an example of flags with future keyword support. */
1066 | #define PARSER_FLAGS(flags) \
1067 | ((flags) ? ((((flags)->cf_flags & PyCF_DONT_IMPLY_DEDENT0x0200) ? \
1068 | PyPARSE_DONT_IMPLY_DEDENT0x0002 : 0) \
1069 | | ((flags)->cf_flags & CO_FUTURE_WITH_STATEMENT0x8000 ? \
1070 | PyPARSE_WITH_IS_KEYWORD : 0)) : 0)
1071 | #endif
1072 |
1073 | int
1074 | PyRun_InteractiveOneFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
1075 | {
1076 | PyObject *m, *d, *v, *w, *oenc = NULL((void *)0);
1077 | mod_ty mod;
1078 | PyArena *arena;
1079 | char *ps1 = "", *ps2 = "", *enc = NULL((void *)0);
1080 | int errcode = 0;
1081 |
1082 | if (fp == stdin__stdinp) {
1083 | /* Fetch encoding from sys.stdin */
1084 | v = PySys_GetObject("stdin");
1085 | if (v == NULL((void *)0) || v == Py_None(&_Py_NoneStruct))
1086 | return -1;
1087 | oenc = PyObject_GetAttrString(v, "encoding");
1088 | if (!oenc)
1089 | return -1;
1090 | enc = _PyUnicode_AsString(oenc);
1091 | if (enc == NULL((void *)0))
1092 | return -1;
1093 | }
1094 | v = PySys_GetObject("ps1");
1095 | if (v != NULL((void *)0)) {
1096 | v = PyObject_Str(v);
1097 | if (v == NULL((void *)0))
1098 | PyErr_Clear();
1099 | else if (PyUnicode_Check(v)((((((PyObject*)(v))->ob_type))->tp_flags & ((1L<< 28))) != 0)) {
1100 | ps1 = _PyUnicode_AsString(v);
1101 | if (ps1 == NULL((void *)0)) {
1102 | PyErr_Clear();
1103 | ps1 = "";
1104 | }
1105 | }
1106 | }
1107 | w = PySys_GetObject("ps2");
1108 | if (w != NULL((void *)0)) {
1109 | w = PyObject_Str(w);
1110 | if (w == NULL((void *)0))
1111 | PyErr_Clear();
1112 | else if (PyUnicode_Check(w)((((((PyObject*)(w))->ob_type))->tp_flags & ((1L<< 28))) != 0)) {
1113 | ps2 = _PyUnicode_AsString(w);
1114 | if (ps2 == NULL((void *)0)) {
1115 | PyErr_Clear();
1116 | ps2 = "";
1117 | }
1118 | }
1119 | }
1120 | arena = PyArena_New();
1121 | if (arena == NULL((void *)0)) {
1122 | Py_XDECREF(v)do { if ((v) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt != 0) { if (((PyObject*)v)-> ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c", 1122 , (PyObject *)(v)); } else _Py_Dealloc((PyObject *)(v)); } while (0); } while (0);
1123 | Py_XDECREF(w)do { if ((w) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(w))->ob_refcnt != 0) { if (((PyObject*)w)-> ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c", 1123 , (PyObject *)(w)); } else _Py_Dealloc((PyObject *)(w)); } while (0); } while (0);
1124 | Py_XDECREF(oenc)do { if ((oenc) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(oenc))->ob_refcnt != 0) { if (((PyObject *)oenc)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 1124, (PyObject *)(oenc)); } else _Py_Dealloc((PyObject *)( oenc)); } while (0); } while (0);
1125 | return -1;
1126 | }
1127 | mod = PyParser_ASTFromFile(fp, filename, enc,
1128 | Py_single_input256, ps1, ps2,
1129 | flags, &errcode, arena);
1130 | Py_XDECREF(v)do { if ((v) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt != 0) { if (((PyObject*)v)-> ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c", 1130 , (PyObject *)(v)); } else _Py_Dealloc((PyObject *)(v)); } while (0); } while (0);
1131 | Py_XDECREF(w)do { if ((w) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(w))->ob_refcnt != 0) { if (((PyObject*)w)-> ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c", 1131 , (PyObject *)(w)); } else _Py_Dealloc((PyObject *)(w)); } while (0); } while (0);
1132 | Py_XDECREF(oenc)do { if ((oenc) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(oenc))->ob_refcnt != 0) { if (((PyObject *)oenc)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 1132, (PyObject *)(oenc)); } else _Py_Dealloc((PyObject *)( oenc)); } while (0); } while (0);
1133 | if (mod == NULL((void *)0)) {
1134 | PyArena_Free(arena);
1135 | if (errcode == E_EOF11) {
1136 | PyErr_Clear();
1137 | return E_EOF11;
1138 | }
1139 | PyErr_Print();
1140 | return -1;
1141 | }
1142 | m = PyImport_AddModule("__main__");
1143 | if (m == NULL((void *)0)) {
1144 | PyArena_Free(arena);
1145 | return -1;
1146 | }
1147 | d = PyModule_GetDict(m);
1148 | v = run_mod(mod, filename, d, d, flags, arena);
1149 | PyArena_Free(arena);
1150 | flush_io();
1151 | if (v == NULL((void *)0)) {
1152 | PyErr_Print();
1153 | return -1;
1154 | }
1155 | Py_DECREF(v)do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt != 0) { if (((PyObject*)v)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 1155, (PyObject *)(v)); } else _Py_Dealloc ((PyObject *)(v)); } while (0);
1156 | return 0;
1157 | }
1158 |
1159 | /* Check whether a file maybe a pyc file: Look at the extension,
1160 | the file type, and, if we may close it, at the first few bytes. */
1161 |
1162 | static int
1163 | maybe_pyc_file(FILE *fp, const char* filename, const char* ext, int closeit)
1164 | {
1165 | if (strcmp(ext, ".pyc") == 0 || strcmp(ext, ".pyo") == 0)
1166 | return 1;
1167 |
1168 | /* Only look into the file if we are allowed to close it, since
1169 | it then should also be seekable. */
1170 | if (closeit) {
1171 | /* Read only two bytes of the magic. If the file was opened in
1172 | text mode, the bytes 3 and 4 of the magic (\r\n) might not
1173 | be read as they are on disk. */
1174 | unsigned int halfmagic = PyImport_GetMagicNumber() & 0xFFFF;
1175 | unsigned char buf[2];
1176 | /* Mess: In case of -x, the stream is NOT at its start now,
1177 | and ungetc() was used to push back the first newline,
1178 | which makes the current stream position formally undefined,
1179 | and a x-platform nightmare.
1180 | Unfortunately, we have no direct way to know whether -x
1181 | was specified. So we use a terrible hack: if the current
1182 | stream position is not 0, we assume -x was specified, and
1183 | give up. Bug 132850 on SourceForge spells out the
1184 | hopelessness of trying anything else (fseek and ftell
1185 | don't work predictably x-platform for text-mode files).
1186 | */
1187 | int ispyc = 0;
1188 | if (ftell(fp) == 0) {
1189 | if (fread(buf, 1, 2, fp) == 2 &&
1190 | ((unsigned int)buf[1]<<8 | buf[0]) == halfmagic)
1191 | ispyc = 1;
1192 | rewind(fp);
1193 | }
1194 | return ispyc;
1195 | }
1196 | return 0;
1197 | }
1198 |
1199 | int
1200 | PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit,
1201 | PyCompilerFlags *flags)
1202 | {
1203 | PyObject *m, *d, *v;
1204 | const char *ext;
1205 | int set_file_name = 0, ret;
1206 | size_t len;
1207 |
1208 | m = PyImport_AddModule("__main__");
1209 | if (m == NULL((void *)0))
1210 | return -1;
1211 | d = PyModule_GetDict(m);
1212 | if (PyDict_GetItemString(d, "__file__") == NULL((void *)0)) {
1213 | PyObject *f;
1214 | f = PyUnicode_DecodeFSDefaultPyUnicodeUCS2_DecodeFSDefault(filename);
1215 | if (f == NULL((void *)0))
1216 | return -1;
1217 | if (PyDict_SetItemString(d, "__file__", f) < 0) {
1218 | Py_DECREF(f)do { if (_Py_RefTotal-- , --((PyObject*)(f))->ob_refcnt != 0) { if (((PyObject*)f)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 1218, (PyObject *)(f)); } else _Py_Dealloc ((PyObject *)(f)); } while (0);
1219 | return -1;
1220 | }
1221 | if (PyDict_SetItemString(d, "__cached__", Py_None(&_Py_NoneStruct)) < 0)
1222 | return -1;
1223 | set_file_name = 1;
1224 | Py_DECREF(f)do { if (_Py_RefTotal-- , --((PyObject*)(f))->ob_refcnt != 0) { if (((PyObject*)f)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 1224, (PyObject *)(f)); } else _Py_Dealloc ((PyObject *)(f)); } while (0);
1225 | }
1226 | len = strlen(filename);
1227 | ext = filename + len - (len > 4 ? 4 : 0);
1228 | if (maybe_pyc_file(fp, filename, ext, closeit)) {
1229 | /* Try to run a pyc file. First, re-open in binary */
1230 | if (closeit)
1231 | fclose(fp);
1232 | if ((fp = fopen(filename, "rb")) == NULL((void *)0)) {
1233 | fprintf(stderr__stderrp, "python: Can't reopen .pyc file\n");
1234 | ret = -1;
1235 | goto done;
1236 | }
1237 | /* Turn on optimization if a .pyo file is given */
1238 | if (strcmp(ext, ".pyo") == 0)
1239 | Py_OptimizeFlag = 1;
1240 | v = run_pyc_file(fp, filename, d, d, flags);
1241 | } else {
1242 | v = PyRun_FileExFlags(fp, filename, Py_file_input257, d, d,
1243 | closeit, flags);
1244 | }
1245 | flush_io();
1246 | if (v == NULL((void *)0)) {
1247 | PyErr_Print();
1248 | ret = -1;
1249 | goto done;
1250 | }
1251 | Py_DECREF(v)do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt != 0) { if (((PyObject*)v)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 1251, (PyObject *)(v)); } else _Py_Dealloc ((PyObject *)(v)); } while (0);
1252 | ret = 0;
1253 | done:
1254 | if (set_file_name && PyDict_DelItemString(d, "__file__"))
1255 | PyErr_Clear();
1256 | return ret;
1257 | }
1258 |
1259 | int
1260 | PyRun_SimpleStringFlags(const char *command, PyCompilerFlags *flags)
1261 | {
1262 | PyObject *m, *d, *v;
1263 | m = PyImport_AddModule("__main__");
1264 | if (m == NULL((void *)0))
1265 | return -1;
1266 | d = PyModule_GetDict(m);
1267 | v = PyRun_StringFlags(command, Py_file_input257, d, d, flags);
1268 | if (v == NULL((void *)0)) {
1269 | PyErr_Print();
1270 | return -1;
1271 | }
1272 | Py_DECREF(v)do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt != 0) { if (((PyObject*)v)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 1272, (PyObject *)(v)); } else _Py_Dealloc ((PyObject *)(v)); } while (0);
1273 | return 0;
1274 | }
1275 |
1276 | static int
1277 | parse_syntax_error(PyObject *err, PyObject **message, const char **filename,
1278 | int *lineno, int *offset, const char **text)
1279 | {
1280 | long hold;
1281 | PyObject *v;
1282 |
1283 | /* old style errors */
1284 | if (PyTuple_Check(err)((((((PyObject*)(err))->ob_type))->tp_flags & ((1L<< 26))) != 0))
1285 | return PyArg_ParseTuple(err, "O(ziiz)", message, filename,
1286 | lineno, offset, text);
1287 |
1288 | /* new style errors. `err' is an instance */
1289 |
1290 | if (! (v = PyObject_GetAttrString(err, "msg")))
1291 | goto finally;
1292 | *message = v;
1293 |
1294 | if (!(v = PyObject_GetAttrString(err, "filename")))
1295 | goto finally;
1296 | if (v == Py_None(&_Py_NoneStruct))
1297 | *filename = NULL((void *)0);
1298 | else if (! (*filename = _PyUnicode_AsString(v)))
1299 | goto finally;
1300 |
1301 | Py_DECREF(v)do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt != 0) { if (((PyObject*)v)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 1301, (PyObject *)(v)); } else _Py_Dealloc ((PyObject *)(v)); } while (0);
1302 | if (!(v = PyObject_GetAttrString(err, "lineno")))
1303 | goto finally;
1304 | hold = PyLong_AsLong(v);
1305 | Py_DECREF(v)do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt != 0) { if (((PyObject*)v)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 1305, (PyObject *)(v)); } else _Py_Dealloc ((PyObject *)(v)); } while (0);
1306 | v = NULL((void *)0);
1307 | if (hold < 0 && PyErr_Occurred())
1308 | goto finally;
1309 | *lineno = (int)hold;
1310 |
1311 | if (!(v = PyObject_GetAttrString(err, "offset")))
1312 | goto finally;
1313 | if (v == Py_None(&_Py_NoneStruct)) {
1314 | *offset = -1;
1315 | Py_DECREF(v)do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt != 0) { if (((PyObject*)v)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 1315, (PyObject *)(v)); } else _Py_Dealloc ((PyObject *)(v)); } while (0);
1316 | v = NULL((void *)0);
1317 | } else {
1318 | hold = PyLong_AsLong(v);
1319 | Py_DECREF(v)do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt != 0) { if (((PyObject*)v)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 1319, (PyObject *)(v)); } else _Py_Dealloc ((PyObject *)(v)); } while (0);
1320 | v = NULL((void *)0);
1321 | if (hold < 0 && PyErr_Occurred())
1322 | goto finally;
1323 | *offset = (int)hold;
1324 | }
1325 |
1326 | if (!(v = PyObject_GetAttrString(err, "text")))
1327 | goto finally;
1328 | if (v == Py_None(&_Py_NoneStruct))
1329 | *text = NULL((void *)0);
1330 | else if (!PyUnicode_Check(v)((((((PyObject*)(v))->ob_type))->tp_flags & ((1L<< 28))) != 0) ||
1331 | !(*text = _PyUnicode_AsString(v)))
1332 | goto finally;
1333 | Py_DECREF(v)do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt != 0) { if (((PyObject*)v)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 1333, (PyObject *)(v)); } else _Py_Dealloc ((PyObject *)(v)); } while (0);
1334 | return 1;
1335 |
1336 | finally:
1337 | Py_XDECREF(v)do { if ((v) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt != 0) { if (((PyObject*)v)-> ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c", 1337 , (PyObject *)(v)); } else _Py_Dealloc((PyObject *)(v)); } while (0); } while (0);
1338 | return 0;
1339 | }
1340 |
1341 | void
1342 | PyErr_Print(void)
1343 | {
1344 | PyErr_PrintEx(1);
1345 | }
1346 |
1347 | static void
1348 | print_error_text(PyObject *f, int offset, const char *text)
1349 | {
1350 | char *nl;
1351 | if (offset >= 0) {
1352 | if (offset > 0 && offset == strlen(text) && text[offset - 1] == '\n')
1353 | offset--;
1354 | for (;;) {
1355 | nl = strchr(text, '\n');
1356 | if (nl == NULL((void *)0) || nl-text >= offset)
1357 | break;
1358 | offset -= (int)(nl+1-text);
1359 | text = nl+1;
1360 | }
1361 | while (*text == ' ' || *text == '\t') {
1362 | text++;
1363 | offset--;
1364 | }
1365 | }
1366 | PyFile_WriteString(" ", f);
1367 | PyFile_WriteString(text, f);
1368 | if (*text == '\0' || text[strlen(text)-1] != '\n')
1369 | PyFile_WriteString("\n", f);
1370 | if (offset == -1)
1371 | return;
1372 | PyFile_WriteString(" ", f);
1373 | while (--offset > 0)
1374 | PyFile_WriteString(" ", f);
1375 | PyFile_WriteString("^\n", f);
1376 | }
1377 |
1378 | static void
1379 | handle_system_exit(void)
1380 | {
1381 | PyObject *exception, *value, *tb;
1382 | int exitcode = 0;
1383 |
1384 | if (Py_InspectFlag)
1385 | /* Don't exit if -i flag was given. This flag is set to 0
1386 | * when entering interactive mode for inspecting. */
1387 | return;
1388 |
1389 | PyErr_Fetch(&exception, &value, &tb);
1390 | fflush(stdout__stdoutp);
1391 | if (value == NULL((void *)0) || value == Py_None(&_Py_NoneStruct))
1392 | goto done;
1393 | if (PyExceptionInstance_Check(value)((((value)->ob_type)->tp_flags & ((1L<<30))) != 0)) {
1394 | /* The error code should be in the `code' attribute. */
1395 | PyObject *code = PyObject_GetAttrString(value, "code");
1396 | if (code) {
1397 | Py_DECREF(value)do { if (_Py_RefTotal-- , --((PyObject*)(value))->ob_refcnt != 0) { if (((PyObject*)value)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 1397, (PyObject *)(value)); } else _Py_Dealloc ((PyObject *)(value)); } while (0);
1398 | value = code;
1399 | if (value == Py_None(&_Py_NoneStruct))
1400 | goto done;
1401 | }
1402 | /* If we failed to dig out the 'code' attribute,
1403 | just let the else clause below print the error. */
1404 | }
1405 | if (PyLong_Check(value)((((((PyObject*)(value))->ob_type))->tp_flags & ((1L <<24))) != 0))
1406 | exitcode = (int)PyLong_AsLong(value);
1407 | else {
1408 | PyObject *sys_stderr = PySys_GetObject("stderr");
1409 | if (sys_stderr != NULL((void *)0) && sys_stderr != Py_None(&_Py_NoneStruct)) {
1410 | PyFile_WriteObject(value, sys_stderr, Py_PRINT_RAW1);
1411 | } else {
1412 | PyObject_Print(value, stderr__stderrp, Py_PRINT_RAW1);
1413 | fflush(stderr__stderrp);
1414 | }
1415 | PySys_WriteStderr("\n");
1416 | exitcode = 1;
1417 | }
1418 | done:
1419 | /* Restore and clear the exception info, in order to properly decref
1420 | * the exception, value, and traceback. If we just exit instead,
1421 | * these leak, which confuses PYTHONDUMPREFS output, and may prevent
1422 | * some finalizers from running.
1423 | */
1424 | PyErr_Restore(exception, value, tb);
1425 | PyErr_Clear();
1426 | Py_Exit(exitcode);
1427 | /* NOTREACHED */
1428 | }
1429 |
1430 | void
1431 | PyErr_PrintEx(int set_sys_last_vars)
1432 | {
1433 | PyObject *exception, *v, *tb, *hook;
1434 |
1435 | if (PyErr_ExceptionMatches(PyExc_SystemExit)) {
1436 | handle_system_exit();
1437 | }
1438 | PyErr_Fetch(&exception, &v, &tb);
1439 | if (exception == NULL((void *)0))
1440 | return;
1441 | PyErr_NormalizeException(&exception, &v, &tb);
1442 | if (tb == NULL((void *)0)) {
1443 | tb = Py_None(&_Py_NoneStruct);
1444 | Py_INCREF(tb)( _Py_RefTotal++ , ((PyObject*)(tb))->ob_refcnt++);
1445 | }
1446 | PyException_SetTraceback(v, tb);
1447 | if (exception == NULL((void *)0))
1448 | return;
1449 | /* Now we know v != NULL too */
1450 | if (set_sys_last_vars) {
1451 | PySys_SetObject("last_type", exception);
1452 | PySys_SetObject("last_value", v);
1453 | PySys_SetObject("last_traceback", tb);
1454 | }
1455 | hook = PySys_GetObject("excepthook");
1456 | if (hook) {
1457 | PyObject *args = PyTuple_Pack(3, exception, v, tb);
1458 | PyObject *result = PyEval_CallObject(hook, args)PyEval_CallObjectWithKeywords(hook, args, (PyObject *)((void * )0));
1459 | if (result == NULL((void *)0)) {
1460 | PyObject *exception2, *v2, *tb2;
1461 | if (PyErr_ExceptionMatches(PyExc_SystemExit)) {
1462 | handle_system_exit();
1463 | }
1464 | PyErr_Fetch(&exception2, &v2, &tb2);
1465 | PyErr_NormalizeException(&exception2, &v2, &tb2);
1466 | /* It should not be possible for exception2 or v2
1467 | to be NULL. However PyErr_Display() can't
1468 | tolerate NULLs, so just be safe. */
1469 | if (exception2 == NULL((void *)0)) {
1470 | exception2 = Py_None(&_Py_NoneStruct);
1471 | Py_INCREF(exception2)( _Py_RefTotal++ , ((PyObject*)(exception2))->ob_refcnt++);
1472 | }
1473 | if (v2 == NULL((void *)0)) {
1474 | v2 = Py_None(&_Py_NoneStruct);
1475 | Py_INCREF(v2)( _Py_RefTotal++ , ((PyObject*)(v2))->ob_refcnt++);
1476 | }
1477 | fflush(stdout__stdoutp);
1478 | PySys_WriteStderr("Error in sys.excepthook:\n");
1479 | PyErr_Display(exception2, v2, tb2);
1480 | PySys_WriteStderr("\nOriginal exception was:\n");
1481 | PyErr_Display(exception, v, tb);
1482 | Py_DECREF(exception2)do { if (_Py_RefTotal-- , --((PyObject*)(exception2))->ob_refcnt != 0) { if (((PyObject*)exception2)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 1482, (PyObject *)(exception2)); } else _Py_Dealloc((PyObject *)(exception2)); } while (0);
1483 | Py_DECREF(v2)do { if (_Py_RefTotal-- , --((PyObject*)(v2))->ob_refcnt != 0) { if (((PyObject*)v2)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 1483, (PyObject *)(v2)); } else _Py_Dealloc ((PyObject *)(v2)); } while (0);
1484 | Py_XDECREF(tb2)do { if ((tb2) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(tb2))->ob_refcnt != 0) { if (((PyObject* )tb2)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 1484, (PyObject *)(tb2)); } else _Py_Dealloc((PyObject *)(tb2 )); } while (0); } while (0);
1485 | }
1486 | Py_XDECREF(result)do { if ((result) == ((void *)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(result))->ob_refcnt != 0) { if (((PyObject *)result)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 1486, (PyObject *)(result)); } else _Py_Dealloc((PyObject * )(result)); } while (0); } while (0);
1487 | Py_XDECREF(args)do { if ((args) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(args))->ob_refcnt != 0) { if (((PyObject *)args)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 1487, (PyObject *)(args)); } else _Py_Dealloc((PyObject *)( args)); } while (0); } while (0);
1488 | } else {
1489 | PySys_WriteStderr("sys.excepthook is missing\n");
1490 | PyErr_Display(exception, v, tb);
1491 | }
1492 | Py_XDECREF(exception)do { if ((exception) == ((void *)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(exception))->ob_refcnt != 0) { if (((PyObject *)exception)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 1492, (PyObject *)(exception)); } else _Py_Dealloc((PyObject *)(exception)); } while (0); } while (0);
1493 | Py_XDECREF(v)do { if ((v) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt != 0) { if (((PyObject*)v)-> ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c", 1493 , (PyObject *)(v)); } else _Py_Dealloc((PyObject *)(v)); } while (0); } while (0);
1494 | Py_XDECREF(tb)do { if ((tb) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(tb))->ob_refcnt != 0) { if (((PyObject*)tb )->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 1494, (PyObject *)(tb)); } else _Py_Dealloc((PyObject *)(tb )); } while (0); } while (0);
1495 | }
1496 |
1497 | static void
1498 | print_exception(PyObject *f, PyObject *value)
1499 | {
1500 | int err = 0;
1501 | PyObject *type, *tb;
1502 |
1503 | if (!PyExceptionInstance_Check(value)((((value)->ob_type)->tp_flags & ((1L<<30))) != 0)) {
1 | Taking false branch
1504 | PyFile_WriteString("TypeError: print_exception(): Exception expected for value, ", f);
1505 | PyFile_WriteString(Py_TYPE(value)(((PyObject*)(value))->ob_type)->tp_name, f);
1506 | PyFile_WriteString(" found\n", f);
1507 | return;
1508 | }
1509 |
1510 | Py_INCREF(value)( _Py_RefTotal++ , ((PyObject*)(value))->ob_refcnt++);
1511 | fflush(stdout__stdoutp);
1512 | type = (PyObject *) Py_TYPE(value)(((PyObject*)(value))->ob_type);
1513 | tb = PyException_GetTraceback(value);
1514 | if (tb && tb != Py_None(&_Py_NoneStruct))
2 | Taking false branch
1515 | err = PyTraceBack_Print(tb, f);
1516 | if (err == 0 &&
3 | Taking false branch
1517 | PyObject_HasAttrString(value, "print_file_and_line"))
1518 | {
1519 | PyObject *message;
1520 | const char *filename, *text;
1521 | int lineno, offset;
1522 | if (!parse_syntax_error(value, &message, &filename,
1523 | &lineno, &offset, &text))
1524 | PyErr_Clear();
1525 | else {
1526 | char buf[10];
1527 | PyFile_WriteString(" File \"", f);
1528 | if (filename == NULL((void *)0))
1529 | PyFile_WriteString("<string>", f);
1530 | else
1531 | PyFile_WriteString(filename, f);
1532 | PyFile_WriteString("\", line ", f);
1533 | PyOS_snprintf(buf, sizeof(buf), "%d", lineno);
1534 | PyFile_WriteString(buf, f);
1535 | PyFile_WriteString("\n", f);
1536 | if (text != NULL((void *)0))
1537 | print_error_text(f, offset, text);
1538 | Py_DECREF(value)do { if (_Py_RefTotal-- , --((PyObject*)(value))->ob_refcnt != 0) { if (((PyObject*)value)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 1538, (PyObject *)(value)); } else _Py_Dealloc ((PyObject *)(value)); } while (0);
1539 | value = message;
1540 | /* Can't be bothered to check all those
1541 | PyFile_WriteString() calls */
1542 | if (PyErr_Occurred())
1543 | err = -1;
1544 | }
1545 | }
1546 | if (err) {
4 | Taking false branch
1547 | /* Don't do anything else */
1548 | }
1549 | else {
1550 | PyObject* moduleName;
1551 | char* className;
1552 | assert(PyExceptionClass_Check(type))(__builtin_expect(!((((((((PyObject*)((type)))->ob_type))-> tp_flags & ((1L<<31))) != 0) && ((((PyTypeObject *)(type))->tp_flags & ((1L<<30))) != 0))), 0) ? __assert_rtn (__func__, "Python/pythonrun.c", 1552, "PyExceptionClass_Check(type)" ) : (void)0);
1553 | className = PyExceptionClass_Name(type)((char *)(((PyTypeObject*)(type))->tp_name));
1554 | if (className != NULL((void *)0)) {
5 | Taking false branch
1555 | char *dot = strrchr(className, '.');
1556 | if (dot != NULL((void *)0))
1557 | className = dot+1;
1558 | }
1559 |
1560 | moduleName = PyObject_GetAttrString(type, "__module__");
1561 | if (moduleName == NULL((void *)0) || !PyUnicode_Check(moduleName)((((((PyObject*)(moduleName))->ob_type))->tp_flags & ((1L<<28))) != 0))
6 | Taking true branch
1562 | {
1563 | Py_DECREF(moduleName)do { if (_Py_RefTotal-- , --((PyObject*)(moduleName))->ob_refcnt != 0) { if (((PyObject*)moduleName)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 1563, (PyObject *)(moduleName)); } else _Py_Dealloc((PyObject *)(moduleName)); } while (0);
7 | Within the expansion of the macro 'Py_DECREF':
a | Access to field 'ob_refcnt' results in a dereference of a null pointer (loaded from variable 'moduleName')
1564 | err = PyFile_WriteString("<unknown>", f);
1565 | }
1566 | else {
1567 | char* modstr = _PyUnicode_AsString(moduleName);
1568 | if (modstr && strcmp(modstr, "builtins"))
1569 | {
1570 | err = PyFile_WriteString(modstr, f);
1571 | err += PyFile_WriteString(".", f);
1572 | }
1573 | Py_DECREF(moduleName)do { if (_Py_RefTotal-- , --((PyObject*)(moduleName))->ob_refcnt != 0) { if (((PyObject*)moduleName)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 1573, (PyObject *)(moduleName)); } else _Py_Dealloc((PyObject *)(moduleName)); } while (0);
1574 | }
1575 | if (err == 0) {
1576 | if (className == NULL((void *)0))
1577 | err = PyFile_WriteString("<unknown>", f);
1578 | else
1579 | err = PyFile_WriteString(className, f);
1580 | }
1581 | }
1582 | if (err == 0 && (value != Py_None(&_Py_NoneStruct))) {
1583 | PyObject *s = PyObject_Str(value);
1584 | /* only print colon if the str() of the
1585 | object is not the empty string
1586 | */
1587 | if (s == NULL((void *)0))
1588 | err = -1;
1589 | else if (!PyUnicode_Check(s)((((((PyObject*)(s))->ob_type))->tp_flags & ((1L<< 28))) != 0) ||
1590 | PyUnicode_GetSizePyUnicodeUCS2_GetSize(s) != 0)
1591 | err = PyFile_WriteString(": ", f);
1592 | if (err == 0)
1593 | err = PyFile_WriteObject(s, f, Py_PRINT_RAW1);
1594 | Py_XDECREF(s)do { if ((s) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(s))->ob_refcnt != 0) { if (((PyObject*)s)-> ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c", 1594 , (PyObject *)(s)); } else _Py_Dealloc((PyObject *)(s)); } while (0); } while (0);
1595 | }
1596 | /* try to write a newline in any case */
1597 | err += PyFile_WriteString("\n", f);
1598 | Py_XDECREF(tb)do { if ((tb) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(tb))->ob_refcnt != 0) { if (((PyObject*)tb )->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 1598, (PyObject *)(tb)); } else _Py_Dealloc((PyObject *)(tb )); } while (0); } while (0);
1599 | Py_DECREF(value)do { if (_Py_RefTotal-- , --((PyObject*)(value))->ob_refcnt != 0) { if (((PyObject*)value)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 1599, (PyObject *)(value)); } else _Py_Dealloc ((PyObject *)(value)); } while (0);
1600 | /* If an error happened here, don't show it.
1601 | XXX This is wrong, but too many callers rely on this behavior. */
1602 | if (err != 0)
1603 | PyErr_Clear();
1604 | }
1605 |
1606 | static const char *cause_message =
1607 | "\nThe above exception was the direct cause "
1608 | "of the following exception:\n\n";
1609 |
1610 | static const char *context_message =
1611 | "\nDuring handling of the above exception, "
1612 | "another exception occurred:\n\n";
1613 |
1614 | static void
1615 | print_exception_recursive(PyObject *f, PyObject *value, PyObject *seen)
1616 | {
1617 | int err = 0, res;
1618 | PyObject *cause, *context;
1619 |
1620 | if (seen != NULL((void *)0)) {
1621 | /* Exception chaining */
1622 | if (PySet_Add(seen, value) == -1)
1623 | PyErr_Clear();
1624 | else if (PyExceptionInstance_Check(value)((((value)->ob_type)->tp_flags & ((1L<<30))) != 0)) {
1625 | cause = PyException_GetCause(value);
1626 | context = PyException_GetContext(value);
1627 | if (cause) {
1628 | res = PySet_Contains(seen, cause);
1629 | if (res == -1)
1630 | PyErr_Clear();
1631 | if (res == 0) {
1632 | print_exception_recursive(
1633 | f, cause, seen);
1634 | err |= PyFile_WriteString(
1635 | cause_message, f);
1636 | }
1637 | }
1638 | else if (context) {
1639 | res = PySet_Contains(seen, context);
1640 | if (res == -1)
1641 | PyErr_Clear();
1642 | if (res == 0) {
1643 | print_exception_recursive(
1644 | f, context, seen);
1645 | err |= PyFile_WriteString(
1646 | context_message, f);
1647 | }
1648 | }
1649 | Py_XDECREF(context)do { if ((context) == ((void *)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(context))->ob_refcnt != 0) { if (((PyObject *)context)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 1649, (PyObject *)(context)); } else _Py_Dealloc((PyObject * )(context)); } while (0); } while (0);
1650 | Py_XDECREF(cause)do { if ((cause) == ((void *)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(cause))->ob_refcnt != 0) { if (((PyObject *)cause)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 1650, (PyObject *)(cause)); } else _Py_Dealloc((PyObject *) (cause)); } while (0); } while (0);
1651 | }
1652 | }
1653 | print_exception(f, value);
1654 | if (err != 0)
1655 | PyErr_Clear();
1656 | }
1657 |
1658 | void
1659 | PyErr_Display(PyObject *exception, PyObject *value, PyObject *tb)
1660 | {
1661 | PyObject *seen;
1662 | PyObject *f = PySys_GetObject("stderr");
1663 | if (f == Py_None(&_Py_NoneStruct)) {
1664 | /* pass */
1665 | }
1666 | else if (f == NULL((void *)0)) {
1667 | _PyObject_Dump(value);
1668 | fprintf(stderr__stderrp, "lost sys.stderr\n");
1669 | }
1670 | else {
1671 | /* We choose to ignore seen being possibly NULL, and report
1672 | at least the main exception (it could be a MemoryError).
1673 | */
1674 | seen = PySet_New(NULL((void *)0));
1675 | if (seen == NULL((void *)0))
1676 | PyErr_Clear();
1677 | print_exception_recursive(f, value, seen);
1678 | Py_XDECREF(seen)do { if ((seen) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(seen))->ob_refcnt != 0) { if (((PyObject *)seen)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 1678, (PyObject *)(seen)); } else _Py_Dealloc((PyObject *)( seen)); } while (0); } while (0);
1679 | }
1680 | }
1681 |
1682 | PyObject *
1683 | PyRun_StringFlags(const char *str, int start, PyObject *globals,
1684 | PyObject *locals, PyCompilerFlags *flags)
1685 | {
1686 | PyObject *ret = NULL((void *)0);
1687 | mod_ty mod;
1688 | PyArena *arena = PyArena_New();
1689 | if (arena == NULL((void *)0))
1690 | return NULL((void *)0);
1691 |
1692 | mod = PyParser_ASTFromString(str, "<string>", start, flags, arena);
1693 | if (mod != NULL((void *)0))
1694 | ret = run_mod(mod, "<string>", globals, locals, flags, arena);
1695 | PyArena_Free(arena);
1696 | return ret;
1697 | }
1698 |
1699 | PyObject *
1700 | PyRun_FileExFlags(FILE *fp, const char *filename, int start, PyObject *globals,
1701 | PyObject *locals, int closeit, PyCompilerFlags *flags)
1702 | {
1703 | PyObject *ret;
1704 | mod_ty mod;
1705 | PyArena *arena = PyArena_New();
1706 | if (arena == NULL((void *)0))
1707 | return NULL((void *)0);
1708 |
1709 | mod = PyParser_ASTFromFile(fp, filename, NULL((void *)0), start, 0, 0,
1710 | flags, NULL((void *)0), arena);
1711 | if (closeit)
1712 | fclose(fp);
1713 | if (mod == NULL((void *)0)) {
1714 | PyArena_Free(arena);
1715 | return NULL((void *)0);
1716 | }
1717 | ret = run_mod(mod, filename, globals, locals, flags, arena);
1718 | PyArena_Free(arena);
1719 | return ret;
1720 | }
1721 |
1722 | static void
1723 | flush_io(void)
1724 | {
1725 | PyObject *f, *r;
1726 | PyObject *type, *value, *traceback;
1727 |
1728 | /* Save the current exception */
1729 | PyErr_Fetch(&type, &value, &traceback);
1730 |
1731 | f = PySys_GetObject("stderr");
1732 | if (f != NULL((void *)0)) {
1733 | r = PyObject_CallMethod(f, "flush", "");
1734 | if (r)
1735 | Py_DECREF(r)do { if (_Py_RefTotal-- , --((PyObject*)(r))->ob_refcnt != 0) { if (((PyObject*)r)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 1735, (PyObject *)(r)); } else _Py_Dealloc ((PyObject *)(r)); } while (0);
1736 | else
1737 | PyErr_Clear();
1738 | }
1739 | f = PySys_GetObject("stdout");
1740 | if (f != NULL((void *)0)) {
1741 | r = PyObject_CallMethod(f, "flush", "");
1742 | if (r)
1743 | Py_DECREF(r)do { if (_Py_RefTotal-- , --((PyObject*)(r))->ob_refcnt != 0) { if (((PyObject*)r)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 1743, (PyObject *)(r)); } else _Py_Dealloc ((PyObject *)(r)); } while (0);
1744 | else
1745 | PyErr_Clear();
1746 | }
1747 |
1748 | PyErr_Restore(type, value, traceback);
1749 | }
1750 |
1751 | static PyObject *
1752 | run_mod(mod_ty mod, const char *filename, PyObject *globals, PyObject *locals,
1753 | PyCompilerFlags *flags, PyArena *arena)
1754 | {
1755 | PyCodeObject *co;
1756 | PyObject *v;
1757 | co = PyAST_Compile(mod, filename, flags, arena)PyAST_CompileEx(mod, filename, flags, -1, arena);
1758 | if (co == NULL((void *)0))
1759 | return NULL((void *)0);
1760 | v = PyEval_EvalCode((PyObject*)co, globals, locals);
1761 | Py_DECREF(co)do { if (_Py_RefTotal-- , --((PyObject*)(co))->ob_refcnt != 0) { if (((PyObject*)co)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 1761, (PyObject *)(co)); } else _Py_Dealloc ((PyObject *)(co)); } while (0);
1762 | return v;
1763 | }
1764 |
1765 | static PyObject *
1766 | run_pyc_file(FILE *fp, const char *filename, PyObject *globals,
1767 | PyObject *locals, PyCompilerFlags *flags)
1768 | {
1769 | PyCodeObject *co;
1770 | PyObject *v;
1771 | long magic;
1772 | long PyImport_GetMagicNumber(void);
1773 |
1774 | magic = PyMarshal_ReadLongFromFile(fp);
1775 | if (magic != PyImport_GetMagicNumber()) {
1776 | PyErr_SetString(PyExc_RuntimeError,
1777 | "Bad magic number in .pyc file");
1778 | return NULL((void *)0);
1779 | }
1780 | (void) PyMarshal_ReadLongFromFile(fp);
1781 | v = PyMarshal_ReadLastObjectFromFile(fp);
1782 | fclose(fp);
1783 | if (v == NULL((void *)0) || !PyCode_Check(v)((((PyObject*)(v))->ob_type) == &PyCode_Type)) {
1784 | Py_XDECREF(v)do { if ((v) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt != 0) { if (((PyObject*)v)-> ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c", 1784 , (PyObject *)(v)); } else _Py_Dealloc((PyObject *)(v)); } while (0); } while (0);
1785 | PyErr_SetString(PyExc_RuntimeError,
1786 | "Bad code object in .pyc file");
1787 | return NULL((void *)0);
1788 | }
1789 | co = (PyCodeObject *)v;
1790 | v = PyEval_EvalCode((PyObject*)co, globals, locals);
1791 | if (v && flags)
1792 | flags->cf_flags |= (co->co_flags & PyCF_MASK(0x2000 | 0x4000 | 0x8000 | 0x10000 | 0x20000 | 0x40000));
1793 | Py_DECREF(co)do { if (_Py_RefTotal-- , --((PyObject*)(co))->ob_refcnt != 0) { if (((PyObject*)co)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 1793, (PyObject *)(co)); } else _Py_Dealloc ((PyObject *)(co)); } while (0);
1794 | return v;
1795 | }
1796 |
1797 | PyObject *
1798 | Py_CompileStringExFlags(const char *str, const char *filename, int start,
1799 | PyCompilerFlags *flags, int optimize)
1800 | {
1801 | PyCodeObject *co;
1802 | mod_ty mod;
1803 | PyArena *arena = PyArena_New();
1804 | if (arena == NULL((void *)0))
1805 | return NULL((void *)0);
1806 |
1807 | mod = PyParser_ASTFromString(str, filename, start, flags, arena);
1808 | if (mod == NULL((void *)0)) {
1809 | PyArena_Free(arena);
1810 | return NULL((void *)0);
1811 | }
1812 | if (flags && (flags->cf_flags & PyCF_ONLY_AST0x0400)) {
1813 | PyObject *result = PyAST_mod2obj(mod);
1814 | PyArena_Free(arena);
1815 | return result;
1816 | }
1817 | co = PyAST_CompileEx(mod, filename, flags, optimize, arena);
1818 | PyArena_Free(arena);
1819 | return (PyObject *)co;
1820 | }
1821 |
1822 | /* For use in Py_LIMITED_API */
1823 | #undef Py_CompileString
1824 | PyObject *
1825 | PyCompileString(const char *str, const char *filename, int start)
1826 | {
1827 | return Py_CompileStringFlags(str, filename, start, NULL((void *)0));
1828 | }
1829 |
1830 | struct symtable *
1831 | Py_SymtableString(const char *str, const char *filename, int start)
1832 | {
1833 | struct symtable *st;
1834 | mod_ty mod;
1835 | PyCompilerFlags flags;
1836 | PyArena *arena = PyArena_New();
1837 | if (arena == NULL((void *)0))
1838 | return NULL((void *)0);
1839 |
1840 | flags.cf_flags = 0;
1841 | mod = PyParser_ASTFromString(str, filename, start, &flags, arena);
1842 | if (mod == NULL((void *)0)) {
1843 | PyArena_Free(arena);
1844 | return NULL((void *)0);
1845 | }
1846 | st = PySymtable_Build(mod, filename, 0);
1847 | PyArena_Free(arena);
1848 | return st;
1849 | }
1850 |
1851 | /* Preferred access to parser is through AST. */
1852 | mod_ty
1853 | PyParser_ASTFromString(const char *s, const char *filename, int start,
1854 | PyCompilerFlags *flags, PyArena *arena)
1855 | {
1856 | mod_ty mod;
1857 | PyCompilerFlags localflags;
1858 | perrdetail err;
1859 | int iflags = PARSER_FLAGS(flags);
1860 |
1861 | node *n = PyParser_ParseStringFlagsFilenameEx(s, filename,
1862 | &_PyParser_Grammar, start, &err,
1863 | &iflags);
1864 | if (flags == NULL((void *)0)) {
1865 | localflags.cf_flags = 0;
1866 | flags = &localflags;
1867 | }
1868 | if (n) {
1869 | flags->cf_flags |= iflags & PyCF_MASK(0x2000 | 0x4000 | 0x8000 | 0x10000 | 0x20000 | 0x40000);
1870 | mod = PyAST_FromNode(n, flags, filename, arena);
1871 | PyNode_Free(n);
1872 | return mod;
1873 | }
1874 | else {
1875 | err_input(&err);
1876 | return NULL((void *)0);
1877 | }
1878 | }
1879 |
1880 | mod_ty
1881 | PyParser_ASTFromFile(FILE *fp, const char *filename, const char* enc,
1882 | int start, char *ps1,
1883 | char *ps2, PyCompilerFlags *flags, int *errcode,
1884 | PyArena *arena)
1885 | {
1886 | mod_ty mod;
1887 | PyCompilerFlags localflags;
1888 | perrdetail err;
1889 | int iflags = PARSER_FLAGS(flags);
1890 |
1891 | node *n = PyParser_ParseFileFlagsEx(fp, filename, enc,
1892 | &_PyParser_Grammar,
1893 | start, ps1, ps2, &err, &iflags);
1894 | if (flags == NULL((void *)0)) {
1895 | localflags.cf_flags = 0;
1896 | flags = &localflags;
1897 | }
1898 | if (n) {
1899 | flags->cf_flags |= iflags & PyCF_MASK(0x2000 | 0x4000 | 0x8000 | 0x10000 | 0x20000 | 0x40000);
1900 | mod = PyAST_FromNode(n, flags, filename, arena);
1901 | PyNode_Free(n);
1902 | return mod;
1903 | }
1904 | else {
1905 | err_input(&err);
1906 | if (errcode)
1907 | *errcode = err.error;
1908 | return NULL((void *)0);
1909 | }
1910 | }
1911 |
1912 | /* Simplified interface to parsefile -- return node or set exception */
1913 |
1914 | node *
1915 | PyParser_SimpleParseFileFlags(FILE *fp, const char *filename, int start, int flags)
1916 | {
1917 | perrdetail err;
1918 | node *n = PyParser_ParseFileFlags(fp, filename, NULL((void *)0),
1919 | &_PyParser_Grammar,
1920 | start, NULL((void *)0), NULL((void *)0), &err, flags);
1921 | if (n == NULL((void *)0))
1922 | err_input(&err);
1923 |
1924 | return n;
1925 | }
1926 |
1927 | /* Simplified interface to parsestring -- return node or set exception */
1928 |
1929 | node *
1930 | PyParser_SimpleParseStringFlags(const char *str, int start, int flags)
1931 | {
1932 | perrdetail err;
1933 | node *n = PyParser_ParseStringFlags(str, &_PyParser_Grammar,
1934 | start, &err, flags);
1935 | if (n == NULL((void *)0))
1936 | err_input(&err);
1937 | return n;
1938 | }
1939 |
1940 | node *
1941 | PyParser_SimpleParseStringFlagsFilename(const char *str, const char *filename,
1942 | int start, int flags)
1943 | {
1944 | perrdetail err;
1945 | node *n = PyParser_ParseStringFlagsFilename(str, filename,
1946 | &_PyParser_Grammar, start, &err, flags);
1947 | if (n == NULL((void *)0))
1948 | err_input(&err);
1949 | return n;
1950 | }
1951 |
1952 | node *
1953 | PyParser_SimpleParseStringFilename(const char *str, const char *filename, int start)
1954 | {
1955 | return PyParser_SimpleParseStringFlagsFilename(str, filename, start, 0);
1956 | }
1957 |
1958 | /* May want to move a more generalized form of this to parsetok.c or
1959 | even parser modules. */
1960 |
1961 | void
1962 | PyParser_SetError(perrdetail *err)
1963 | {
1964 | err_input(err);
1965 | }
1966 |
1967 | /* Set the error appropriate to the given input error code (see errcode.h) */
1968 |
1969 | static void
1970 | err_input(perrdetail *err)
1971 | {
1972 | PyObject *v, *w, *errtype, *errtext;
1973 | PyObject *msg_obj = NULL((void *)0);
1974 | PyObject *filename;
1975 | char *msg = NULL((void *)0);
1976 |
1977 | errtype = PyExc_SyntaxError;
1978 | switch (err->error) {
1979 | case E_ERROR17:
1980 | return;
1981 | case E_SYNTAX14:
1982 | errtype = PyExc_IndentationError;
1983 | if (err->expected == INDENT5)
1984 | msg = "expected an indented block";
1985 | else if (err->token == INDENT5)
1986 | msg = "unexpected indent";
1987 | else if (err->token == DEDENT6)
1988 | msg = "unexpected unindent";
1989 | else {
1990 | errtype = PyExc_SyntaxError;
1991 | msg = "invalid syntax";
1992 | }
1993 | break;
1994 | case E_TOKEN13:
1995 | msg = "invalid token";
1996 | break;
1997 | case E_EOFS23:
1998 | msg = "EOF while scanning triple-quoted string literal";
1999 | break;
2000 | case E_EOLS24:
2001 | msg = "EOL while scanning string literal";
2002 | break;
2003 | case E_INTR12:
2004 | if (!PyErr_Occurred())
2005 | PyErr_SetNone(PyExc_KeyboardInterrupt);
2006 | goto cleanup;
2007 | case E_NOMEM15:
2008 | PyErr_NoMemory();
2009 | goto cleanup;
2010 | case E_EOF11:
2011 | msg = "unexpected EOF while parsing";
2012 | break;
2013 | case E_TABSPACE18:
2014 | errtype = PyExc_TabError;
2015 | msg = "inconsistent use of tabs and spaces in indentation";
2016 | break;
2017 | case E_OVERFLOW19:
2018 | msg = "expression too long";
2019 | break;
2020 | case E_DEDENT21:
2021 | errtype = PyExc_IndentationError;
2022 | msg = "unindent does not match any outer indentation level";
2023 | break;
2024 | case E_TOODEEP20:
2025 | errtype = PyExc_IndentationError;
2026 | msg = "too many levels of indentation";
2027 | break;
2028 | case E_DECODE22: {
2029 | PyObject *type, *value, *tb;
2030 | PyErr_Fetch(&type, &value, &tb);
2031 | msg = "unknown decode error";
2032 | if (value != NULL((void *)0))
2033 | msg_obj = PyObject_Str(value);
2034 | Py_XDECREF(type)do { if ((type) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(type))->ob_refcnt != 0) { if (((PyObject *)type)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 2034, (PyObject *)(type)); } else _Py_Dealloc((PyObject *)( type)); } while (0); } while (0);
2035 | Py_XDECREF(value)do { if ((value) == ((void *)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(value))->ob_refcnt != 0) { if (((PyObject *)value)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 2035, (PyObject *)(value)); } else _Py_Dealloc((PyObject *) (value)); } while (0); } while (0);
2036 | Py_XDECREF(tb)do { if ((tb) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(tb))->ob_refcnt != 0) { if (((PyObject*)tb )->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 2036, (PyObject *)(tb)); } else _Py_Dealloc((PyObject *)(tb )); } while (0); } while (0);
2037 | break;
2038 | }
2039 | case E_LINECONT25:
2040 | msg = "unexpected character after line continuation character";
2041 | break;
2042 |
2043 | case E_IDENTIFIER26:
2044 | msg = "invalid character in identifier";
2045 | break;
2046 | default:
2047 | fprintf(stderr__stderrp, "error=%d\n", err->error);
2048 | msg = "unknown parsing error";
2049 | break;
2050 | }
2051 | /* err->text may not be UTF-8 in case of decoding errors.
2052 | Explicitly convert to an object. */
2053 | if (!err->text) {
2054 | errtext = Py_None(&_Py_NoneStruct);
2055 | Py_INCREF(Py_None)( _Py_RefTotal++ , ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt ++);
2056 | } else {
2057 | errtext = PyUnicode_DecodeUTF8PyUnicodeUCS2_DecodeUTF8(err->text, strlen(err->text),
2058 | "replace");
2059 | }
2060 | if (err->filename != NULL((void *)0))
2061 | filename = PyUnicode_DecodeFSDefaultPyUnicodeUCS2_DecodeFSDefault(err->filename);
2062 | else {
2063 | Py_INCREF(Py_None)( _Py_RefTotal++ , ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt ++);
2064 | filename = Py_None(&_Py_NoneStruct);
2065 | }
2066 | if (filename != NULL((void *)0))
2067 | v = Py_BuildValue("(NiiN)", filename,
2068 | err->lineno, err->offset, errtext);
2069 | else
2070 | v = NULL((void *)0);
2071 | if (v != NULL((void *)0)) {
2072 | if (msg_obj)
2073 | w = Py_BuildValue("(OO)", msg_obj, v);
2074 | else
2075 | w = Py_BuildValue("(sO)", msg, v);
2076 | } else
2077 | w = NULL((void *)0);
2078 | Py_XDECREF(v)do { if ((v) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt != 0) { if (((PyObject*)v)-> ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c", 2078 , (PyObject *)(v)); } else _Py_Dealloc((PyObject *)(v)); } while (0); } while (0);
2079 | PyErr_SetObject(errtype, w);
2080 | Py_XDECREF(w)do { if ((w) == ((void *)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(w))->ob_refcnt != 0) { if (((PyObject*)w)-> ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c", 2080 , (PyObject *)(w)); } else _Py_Dealloc((PyObject *)(w)); } while (0); } while (0);
2081 | cleanup:
2082 | Py_XDECREF(msg_obj)do { if ((msg_obj) == ((void *)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(msg_obj))->ob_refcnt != 0) { if (((PyObject *)msg_obj)->ob_refcnt < 0) _Py_NegativeRefcount("Python/pythonrun.c" , 2082, (PyObject *)(msg_obj)); } else _Py_Dealloc((PyObject * )(msg_obj)); } while (0); } while (0);
2083 | if (err->text != NULL((void *)0)) {
2084 | PyObject_FREE_PyObject_DebugFree(err->text);
2085 | err->text = NULL((void *)0);
2086 | }
2087 | }
2088 |
2089 | /* Print fatal error message and abort */
2090 |
2091 | void
2092 | Py_FatalError(const char *msg)
2093 | {
2094 | fprintf(stderr__stderrp, "Fatal Python error: %s\n", msg);
2095 | fflush(stderr__stderrp); /* it helps in Windows debug build */
2096 | if (PyErr_Occurred()) {
2097 | PyErr_PrintEx(0);
2098 | }
2099 | #ifdef MS_WINDOWS
2100 | {
2101 | size_t len = strlen(msg);
2102 | WCHAR* buffer;
2103 | size_t i;
2104 |
2105 | /* Convert the message to wchar_t. This uses a simple one-to-one
2106 | conversion, assuming that the this error message actually uses ASCII
2107 | only. If this ceases to be true, we will have to convert. */
2108 | buffer = alloca( (len+1) * (sizeof *buffer))__builtin_alloca((len+1) * (sizeof *buffer));
2109 | for( i=0; i<=len; ++i)
2110 | buffer[i] = msg[i];
2111 | OutputDebugStringW(L"Fatal Python error: ");
2112 | OutputDebugStringW(buffer);
2113 | OutputDebugStringW(L"\n");
2114 | }
2115 | #ifdef _DEBUG
2116 | DebugBreak();
2117 | #endif
2118 | #endif /* MS_WINDOWS */
2119 | abort();
2120 | }
2121 |
2122 | /* Clean up and exit */
2123 |
2124 | #ifdef WITH_THREAD1
2125 | #include "pythread.h"
2126 | #endif
2127 |
2128 | static void (*pyexitfunc)(void) = NULL((void *)0);
2129 | /* For the atexit module. */
2130 | void _Py_PyAtExit(void (*func)(void))
2131 | {
2132 | pyexitfunc = func;
2133 | }
2134 |
2135 | static void
2136 | call_py_exitfuncs(void)
2137 | {
2138 | if (pyexitfunc == NULL((void *)0))
2139 | return;
2140 |
2141 | (*pyexitfunc)();
2142 | PyErr_Clear();
2143 | }
2144 |
2145 | /* Wait until threading._shutdown completes, provided
2146 | the threading module was imported in the first place.
2147 | The shutdown routine will wait until all non-daemon
2148 | "threading" threads have completed. */
2149 | static void
2150 | wait_for_thread_shutdown(void)
2151 | {
2152 | #ifdef WITH_THREAD1
2153 | PyObject *result;
2154 | PyThreadState *tstate = PyThreadState_GET()PyThreadState_Get();
2155 | PyObject *threading = PyMapping_GetItemString(tstate->interp->modules,
2156 | "threading");
2157 | if (threading == NULL((void *)0)) {
2158 | /* threading not imported */
2159 | PyErr_Clear();
2160 | return;
2161 | }
2162 | result = PyObject_CallMethod(threading, "_shutdown", "");
2163 | if (result == NULL((void *)0)) {
2164 | PyErr_WriteUnraisable(threading);
2165 | }
2166 | else {
2167 | Py_DECREF(result)do { if (_Py_RefTotal-- , --((PyObject*)(result))->ob_refcnt != 0) { if (((PyObject*)result)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 2167, (PyObject *)(result)); } else _Py_Dealloc ((PyObject *)(result)); } while (0);
2168 | }
2169 | Py_DECREF(threading)do { if (_Py_RefTotal-- , --((PyObject*)(threading))->ob_refcnt != 0) { if (((PyObject*)threading)->ob_refcnt < 0) _Py_NegativeRefcount ("Python/pythonrun.c", 2169, (PyObject *)(threading)); } else _Py_Dealloc((PyObject *)(threading)); } while (0);
2170 | #endif
2171 | }
2172 |
2173 | #define NEXITFUNCS32 32
2174 | static void (*exitfuncs[NEXITFUNCS32])(void);
2175 | static int nexitfuncs = 0;
2176 |
2177 | int Py_AtExit(void (*func)(void))
2178 | {
2179 | if (nexitfuncs >= NEXITFUNCS32)
2180 | return -1;
2181 | exitfuncs[nexitfuncs++] = func;
2182 | return 0;
2183 | }
2184 |
2185 | static void
2186 | call_ll_exitfuncs(void)
2187 | {
2188 | while (nexitfuncs > 0)
2189 | (*exitfuncs[--nexitfuncs])();
2190 |
2191 | fflush(stdout__stdoutp);
2192 | fflush(stderr__stderrp);
2193 | }
2194 |
2195 | void
2196 | Py_Exit(int sts)
2197 | {
2198 | Py_Finalize();
2199 |
2200 | exit(sts);
2201 | }
2202 |
2203 | static void
2204 | initsigs(void)
2205 | {
2206 | #ifdef SIGPIPE13
2207 | PyOS_setsig(SIGPIPE13, SIG_IGN(void (*)(int))1);
2208 | #endif
2209 | #ifdef SIGXFZ
2210 | PyOS_setsig(SIGXFZ, SIG_IGN(void (*)(int))1);
2211 | #endif
2212 | #ifdef SIGXFSZ25
2213 | PyOS_setsig(SIGXFSZ25, SIG_IGN(void (*)(int))1);
2214 | #endif
2215 | PyOS_InitInterrupts(); /* May imply initsignal() */
2216 | }
2217 |
2218 |
2219 | /* Restore signals that the interpreter has called SIG_IGN on to SIG_DFL.
2220 | *
2221 | * All of the code in this function must only use async-signal-safe functions,
2222 | * listed at `man 7 signal` or
2223 | * http://www.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html.
2224 | */
2225 | void
2226 | _Py_RestoreSignals(void)
2227 | {
2228 | #ifdef SIGPIPE13
2229 | PyOS_setsig(SIGPIPE13, SIG_DFL(void (*)(int))0);
2230 | #endif
2231 | #ifdef SIGXFZ
2232 | PyOS_setsig(SIGXFZ, SIG_DFL(void (*)(int))0);
2233 | #endif
2234 | #ifdef SIGXFSZ25
2235 | PyOS_setsig(SIGXFSZ25, SIG_DFL(void (*)(int))0);
2236 | #endif
2237 | }
2238 |
2239 |
2240 | /*
2241 | * The file descriptor fd is considered ``interactive'' if either
2242 | * a) isatty(fd) is TRUE, or
2243 | * b) the -i flag was given, and the filename associated with
2244 | * the descriptor is NULL or "<stdin>" or "???".
2245 | */
2246 | int
2247 | Py_FdIsInteractive(FILE *fp, const char *filename)
2248 | {
2249 | if (isatty((int)fileno(fp)))
2250 | return 1;
2251 | if (!Py_InteractiveFlag)
2252 | return 0;
2253 | return (filename == NULL((void *)0)) ||
2254 | (strcmp(filename, "<stdin>") == 0) ||
2255 | (strcmp(filename, "???") == 0);
2256 | }
2257 |
2258 |
2259 | #if defined(USE_STACKCHECK)
2260 | #if defined(WIN32) && defined(_MSC_VER)
2261 |
2262 | /* Stack checking for Microsoft C */
2263 |
2264 | #include <malloc.h>
2265 | #include <excpt.h>
2266 |
2267 | /*
2268 | * Return non-zero when we run out of memory on the stack; zero otherwise.
2269 | */
2270 | int
2271 | PyOS_CheckStack(void)
2272 | {
2273 | __try {
2274 | /* alloca throws a stack overflow exception if there's
2275 | not enough space left on the stack */
2276 | alloca(PYOS_STACK_MARGIN * sizeof(void*))__builtin_alloca(2048 * sizeof(void*));
2277 | return 0;
2278 | } __except (GetExceptionCode() == STATUS_STACK_OVERFLOW ?
2279 | EXCEPTION_EXECUTE_HANDLER :
2280 | EXCEPTION_CONTINUE_SEARCH) {
2281 | int errcode = _resetstkoflw();
2282 | if (errcode == 0)
2283 | {
2284 | Py_FatalError("Could not reset the stack!");
2285 | }
2286 | }
2287 | return 1;
2288 | }
2289 |
2290 | #endif /* WIN32 && _MSC_VER */
2291 |
2292 | /* Alternate implementations can be added here... */
2293 |
2294 | #endif /* USE_STACKCHECK */
2295 |
2296 |
2297 | /* Wrappers around sigaction() or signal(). */
2298 |
2299 | PyOS_sighandler_t
2300 | PyOS_getsig(int sig)
2301 | {
2302 | #ifdef HAVE_SIGACTION1
2303 | struct sigaction context;
2304 | if (sigaction(sig, NULL((void *)0), &context) == -1)
2305 | return SIG_ERR((void (*)(int))-1);
2306 | return context.sa_handler__sigaction_u.__sa_handler;
2307 | #else
2308 | PyOS_sighandler_t handler;
2309 | /* Special signal handling for the secure CRT in Visual Studio 2005 */
2310 | #if defined(_MSC_VER) && _MSC_VER >= 1400
2311 | switch (sig) {
2312 | /* Only these signals are valid */
2313 | case SIGINT2:
2314 | case SIGILL4:
2315 | case SIGFPE8:
2316 | case SIGSEGV11:
2317 | case SIGTERM15:
2318 | case SIGBREAK:
2319 | case SIGABRT6:
2320 | break;
2321 | /* Don't call signal() with other values or it will assert */
2322 | default:
2323 | return SIG_ERR((void (*)(int))-1);
2324 | }
2325 | #endif /* _MSC_VER && _MSC_VER >= 1400 */
2326 | handler = signal(sig, SIG_IGN(void (*)(int))1);
2327 | if (handler != SIG_ERR((void (*)(int))-1))
2328 | signal(sig, handler);
2329 | return handler;
2330 | #endif
2331 | }
2332 |
2333 | /*
2334 | * All of the code in this function must only use async-signal-safe functions,
2335 | * listed at `man 7 signal` or
2336 | * http://www.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html.
2337 | */
2338 | PyOS_sighandler_t
2339 | PyOS_setsig(int sig, PyOS_sighandler_t handler)
2340 | {
2341 | #ifdef HAVE_SIGACTION1
2342 | /* Some code in Modules/signalmodule.c depends on sigaction() being
2343 | * used here if HAVE_SIGACTION is defined. Fix that if this code
2344 | * changes to invalidate that assumption.
2345 | */
2346 | struct sigaction context, ocontext;
2347 | context.sa_handler__sigaction_u.__sa_handler = handler;
2348 | sigemptyset(&context.sa_mask)(*(&context.sa_mask) = 0, 0);
2349 | context.sa_flags = 0;
2350 | if (sigaction(sig, &context, &ocontext) == -1)
2351 | return SIG_ERR((void (*)(int))-1);
2352 | return ocontext.sa_handler__sigaction_u.__sa_handler;
2353 | #else
2354 | PyOS_sighandler_t oldhandler;
2355 | oldhandler = signal(sig, handler);
2356 | #ifdef HAVE_SIGINTERRUPT1
2357 | siginterrupt(sig, 1);
2358 | #endif
2359 | return oldhandler;
2360 | #endif
2361 | }
2362 |
2363 | /* Deprecated C API functions still provided for binary compatiblity */
2364 |
2365 | #undef PyParser_SimpleParseFile
2366 | PyAPI_FUNC(node *)node *
2367 | PyParser_SimpleParseFile(FILE *fp, const char *filename, int start)
2368 | {
2369 | return PyParser_SimpleParseFileFlags(fp, filename, start, 0);
2370 | }
2371 |
2372 | #undef PyParser_SimpleParseString
2373 | PyAPI_FUNC(node *)node *
2374 | PyParser_SimpleParseString(const char *str, int start)
2375 | {
2376 | return PyParser_SimpleParseStringFlags(str, start, 0);
2377 | }
2378 |
2379 | #undef PyRun_AnyFile
2380 | PyAPI_FUNC(int)int
2381 | PyRun_AnyFile(FILE *fp, const char *name)
2382 | {
2383 | return PyRun_AnyFileExFlags(fp, name, 0, NULL((void *)0));
2384 | }
2385 |
2386 | #undef PyRun_AnyFileEx
2387 | PyAPI_FUNC(int)int
2388 | PyRun_AnyFileEx(FILE *fp, const char *name, int closeit)
2389 | {
2390 | return PyRun_AnyFileExFlags(fp, name, closeit, NULL((void *)0));
2391 | }
2392 |
2393 | #undef PyRun_AnyFileFlags
2394 | PyAPI_FUNC(int)int
2395 | PyRun_AnyFileFlags(FILE *fp, const char *name, PyCompilerFlags *flags)
2396 | {
2397 | return PyRun_AnyFileExFlags(fp, name, 0, flags);
2398 | }
2399 |
2400 | #undef PyRun_File
2401 | PyAPI_FUNC(PyObject *)PyObject *
2402 | PyRun_File(FILE *fp, const char *p, int s, PyObject *g, PyObject *l)
2403 | {
2404 | return PyRun_FileExFlags(fp, p, s, g, l, 0, NULL((void *)0));
2405 | }
2406 |
2407 | #undef PyRun_FileEx
2408 | PyAPI_FUNC(PyObject *)PyObject *
2409 | PyRun_FileEx(FILE *fp, const char *p, int s, PyObject *g, PyObject *l, int c)
2410 | {
2411 | return PyRun_FileExFlags(fp, p, s, g, l, c, NULL((void *)0));
2412 | }
2413 |
2414 | #undef PyRun_FileFlags
2415 | PyAPI_FUNC(PyObject *)PyObject *
2416 | PyRun_FileFlags(FILE *fp, const char *p, int s, PyObject *g, PyObject *l,
2417 | PyCompilerFlags *flags)
2418 | {
2419 | return PyRun_FileExFlags(fp, p, s, g, l, 0, flags);
2420 | }
2421 |
2422 | #undef PyRun_SimpleFile
2423 | PyAPI_FUNC(int)int
2424 | PyRun_SimpleFile(FILE *f, const char *p)
2425 | {
2426 | return PyRun_SimpleFileExFlags(f, p, 0, NULL((void *)0));
2427 | }
2428 |
2429 | #undef PyRun_SimpleFileEx
2430 | PyAPI_FUNC(int)int
2431 | PyRun_SimpleFileEx(FILE *f, const char *p, int c)
2432 | {
2433 | return PyRun_SimpleFileExFlags(f, p, c, NULL((void *)0));
2434 | }
2435 |
2436 |
2437 | #undef PyRun_String
2438 | PyAPI_FUNC(PyObject *)PyObject *
2439 | PyRun_String(const char *str, int s, PyObject *g, PyObject *l)
2440 | {
2441 | return PyRun_StringFlags(str, s, g, l, NULL((void *)0));
2442 | }
2443 |
2444 | #undef PyRun_SimpleString
2445 | PyAPI_FUNC(int)int
2446 | PyRun_SimpleString(const char *s)
2447 | {
2448 | return PyRun_SimpleStringFlags(s, NULL((void *)0));
2449 | }
2450 |
2451 | #undef Py_CompileString
2452 | PyAPI_FUNC(PyObject *)PyObject *
2453 | Py_CompileString(const char *str, const char *p, int s)
2454 | {
2455 | return Py_CompileStringExFlags(str, p, s, NULL((void *)0), -1);
2456 | }
2457 |
2458 | #undef Py_CompileStringFlags
2459 | PyAPI_FUNC(PyObject *)PyObject *
2460 | Py_CompileStringFlags(const char *str, const char *p, int s,
2461 | PyCompilerFlags *flags)
2462 | {
2463 | return Py_CompileStringExFlags(str, p, s, flags, -1);
2464 | }
2465 |
2466 | #undef PyRun_InteractiveOne
2467 | PyAPI_FUNC(int)int
2468 | PyRun_InteractiveOne(FILE *f, const char *p)
2469 | {
2470 | return PyRun_InteractiveOneFlags(f, p, NULL((void *)0));
2471 | }
2472 |
2473 | #undef PyRun_InteractiveLoop
2474 | PyAPI_FUNC(int)int
2475 | PyRun_InteractiveLoop(FILE *f, const char *p)
2476 | {
2477 | return PyRun_InteractiveLoopFlags(f, p, NULL((void *)0));
2478 | }
2479 |
2480 | #ifdef __cplusplus
2481 | }
2482 | #endif