Branch data Line data Source code
1 : :
2 : : /* Top level execution of Python code (including in __main__) */
3 : :
4 : : /* To help control the interfaces between the startup, execution and
5 : : * shutdown code, the phases are split across separate modules (bootstrap,
6 : : * pythonrun, shutdown)
7 : : */
8 : :
9 : : /* TODO: Cull includes following phase split */
10 : :
11 : : #include <stdbool.h>
12 : :
13 : : #include "Python.h"
14 : :
15 : : #include "pycore_ast.h" // PyAST_mod2obj
16 : : #include "pycore_ceval.h" // _Py_EnterRecursiveCall
17 : : #include "pycore_compile.h" // _PyAST_Compile()
18 : : #include "pycore_interp.h" // PyInterpreterState.importlib
19 : : #include "pycore_object.h" // _PyDebug_PrintTotalRefs()
20 : : #include "pycore_parser.h" // _PyParser_ASTFromString()
21 : : #include "pycore_pyerrors.h" // _PyErr_Fetch, _Py_Offer_Suggestions
22 : : #include "pycore_pylifecycle.h" // _Py_UnhandledKeyboardInterrupt
23 : : #include "pycore_pystate.h" // _PyInterpreterState_GET()
24 : : #include "pycore_sysmodule.h" // _PySys_Audit()
25 : : #include "pycore_traceback.h" // _PyTraceBack_Print_Indented()
26 : :
27 : : #include "errcode.h" // E_EOF
28 : : #include "marshal.h" // PyMarshal_ReadLongFromFile()
29 : :
30 : : #ifdef MS_WINDOWS
31 : : # include "malloc.h" // alloca()
32 : : #endif
33 : :
34 : : #ifdef MS_WINDOWS
35 : : # undef BYTE
36 : : # include "windows.h"
37 : : #endif
38 : :
39 : :
40 : : #ifdef __cplusplus
41 : : extern "C" {
42 : : #endif
43 : :
44 : : /* Forward */
45 : : static void flush_io(void);
46 : : static PyObject *run_mod(mod_ty, PyObject *, PyObject *, PyObject *,
47 : : PyCompilerFlags *, PyArena *);
48 : : static PyObject *run_pyc_file(FILE *, PyObject *, PyObject *,
49 : : PyCompilerFlags *);
50 : : static int PyRun_InteractiveOneObjectEx(FILE *, PyObject *, PyCompilerFlags *);
51 : : static PyObject* pyrun_file(FILE *fp, PyObject *filename, int start,
52 : : PyObject *globals, PyObject *locals, int closeit,
53 : : PyCompilerFlags *flags);
54 : :
55 : :
56 : : int
57 : 363 : _PyRun_AnyFileObject(FILE *fp, PyObject *filename, int closeit,
58 : : PyCompilerFlags *flags)
59 : : {
60 : 363 : int decref_filename = 0;
61 [ - + ]: 363 : if (filename == NULL) {
62 : 0 : filename = PyUnicode_FromString("???");
63 [ # # ]: 0 : if (filename == NULL) {
64 : 0 : PyErr_Print();
65 : 0 : return -1;
66 : : }
67 : 0 : decref_filename = 1;
68 : : }
69 : :
70 : : int res;
71 [ + + ]: 363 : if (_Py_FdIsInteractive(fp, filename)) {
72 : 12 : res = _PyRun_InteractiveLoopObject(fp, filename, flags);
73 [ - + ]: 8 : if (closeit) {
74 : 0 : fclose(fp);
75 : : }
76 : : }
77 : : else {
78 : 351 : res = _PyRun_SimpleFileObject(fp, filename, closeit, flags);
79 : : }
80 : :
81 [ - + ]: 312 : if (decref_filename) {
82 : 0 : Py_DECREF(filename);
83 : : }
84 : 312 : return res;
85 : : }
86 : :
87 : :
88 : : /* Parse input from a file and execute it */
89 : : int
90 : 25 : PyRun_AnyFileExFlags(FILE *fp, const char *filename, int closeit,
91 : : PyCompilerFlags *flags)
92 : : {
93 : : PyObject *filename_obj;
94 [ + - ]: 25 : if (filename != NULL) {
95 : 25 : filename_obj = PyUnicode_DecodeFSDefault(filename);
96 [ - + ]: 25 : if (filename_obj == NULL) {
97 : 0 : PyErr_Print();
98 : 0 : return -1;
99 : : }
100 : : }
101 : : else {
102 : 0 : filename_obj = NULL;
103 : : }
104 : 25 : int res = _PyRun_AnyFileObject(fp, filename_obj, closeit, flags);
105 : 21 : Py_XDECREF(filename_obj);
106 : 21 : return res;
107 : : }
108 : :
109 : :
110 : : int
111 : 12 : _PyRun_InteractiveLoopObject(FILE *fp, PyObject *filename, PyCompilerFlags *flags)
112 : : {
113 : 12 : PyCompilerFlags local_flags = _PyCompilerFlags_INIT;
114 [ - + ]: 12 : if (flags == NULL) {
115 : 0 : flags = &local_flags;
116 : : }
117 : :
118 : 12 : PyThreadState *tstate = _PyThreadState_GET();
119 : 12 : PyObject *v = _PySys_GetAttr(tstate, &_Py_ID(ps1));
120 [ + - ]: 12 : if (v == NULL) {
121 : 12 : _PySys_SetAttr(&_Py_ID(ps1), v = PyUnicode_FromString(">>> "));
122 : 12 : Py_XDECREF(v);
123 : : }
124 : 12 : v = _PySys_GetAttr(tstate, &_Py_ID(ps2));
125 [ + - ]: 12 : if (v == NULL) {
126 : 12 : _PySys_SetAttr(&_Py_ID(ps2), v = PyUnicode_FromString("... "));
127 : 12 : Py_XDECREF(v);
128 : : }
129 : :
130 : : #ifdef Py_REF_DEBUG
131 : : int show_ref_count = _Py_GetConfig()->show_ref_count;
132 : : #endif
133 : 12 : int err = 0;
134 : : int ret;
135 : 12 : int nomem_count = 0;
136 : : do {
137 : 47 : ret = PyRun_InteractiveOneObjectEx(fp, filename, flags);
138 [ + + + - ]: 47 : if (ret == -1 && PyErr_Occurred()) {
139 : : /* Prevent an endless loop after multiple consecutive MemoryErrors
140 : : * while still allowing an interactive command to fail with a
141 : : * MemoryError. */
142 [ + + ]: 25 : if (PyErr_ExceptionMatches(PyExc_MemoryError)) {
143 [ + + ]: 17 : if (++nomem_count > 16) {
144 : 1 : PyErr_Clear();
145 : 1 : err = -1;
146 : 1 : break;
147 : : }
148 : : } else {
149 : 8 : nomem_count = 0;
150 : : }
151 : 24 : PyErr_Print();
152 : 20 : flush_io();
153 : : } else {
154 : 22 : nomem_count = 0;
155 : : }
156 : : #ifdef Py_REF_DEBUG
157 : : if (show_ref_count) {
158 : : _PyDebug_PrintTotalRefs();
159 : : }
160 : : #endif
161 [ + + ]: 42 : } while (ret != E_EOF);
162 : 8 : return err;
163 : : }
164 : :
165 : :
166 : : int
167 : 0 : PyRun_InteractiveLoopFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
168 : : {
169 : 0 : PyObject *filename_obj = PyUnicode_DecodeFSDefault(filename);
170 [ # # ]: 0 : if (filename_obj == NULL) {
171 : 0 : PyErr_Print();
172 : 0 : return -1;
173 : : }
174 : :
175 : 0 : int err = _PyRun_InteractiveLoopObject(fp, filename_obj, flags);
176 : 0 : Py_DECREF(filename_obj);
177 : 0 : return err;
178 : :
179 : : }
180 : :
181 : :
182 : : /* A PyRun_InteractiveOneObject() auxiliary function that does not print the
183 : : * error on failure. */
184 : : static int
185 : 47 : PyRun_InteractiveOneObjectEx(FILE *fp, PyObject *filename,
186 : : PyCompilerFlags *flags)
187 : : {
188 : 47 : PyObject *m, *d, *v, *w, *oenc = NULL;
189 : : mod_ty mod;
190 : : PyArena *arena;
191 : 47 : const char *ps1 = "", *ps2 = "", *enc = NULL;
192 : 47 : int errcode = 0;
193 : 47 : PyThreadState *tstate = _PyThreadState_GET();
194 : :
195 [ + - ]: 47 : if (fp == stdin) {
196 : : /* Fetch encoding from sys.stdin if possible. */
197 : 47 : v = _PySys_GetAttr(tstate, &_Py_ID(stdin));
198 [ + - + - ]: 47 : if (v && v != Py_None) {
199 : 47 : oenc = PyObject_GetAttr(v, &_Py_ID(encoding));
200 [ + - ]: 47 : if (oenc)
201 : 47 : enc = PyUnicode_AsUTF8(oenc);
202 [ - + ]: 47 : if (!enc)
203 : 0 : PyErr_Clear();
204 : : }
205 : : }
206 : 47 : v = _PySys_GetAttr(tstate, &_Py_ID(ps1));
207 [ + - ]: 47 : if (v != NULL) {
208 : 47 : v = PyObject_Str(v);
209 [ - + ]: 47 : if (v == NULL)
210 : 0 : PyErr_Clear();
211 [ + - ]: 47 : else if (PyUnicode_Check(v)) {
212 : 47 : ps1 = PyUnicode_AsUTF8(v);
213 [ - + ]: 47 : if (ps1 == NULL) {
214 : 0 : PyErr_Clear();
215 : 0 : ps1 = "";
216 : : }
217 : : }
218 : : }
219 : 47 : w = _PySys_GetAttr(tstate, &_Py_ID(ps2));
220 [ + - ]: 47 : if (w != NULL) {
221 : 47 : w = PyObject_Str(w);
222 [ - + ]: 47 : if (w == NULL)
223 : 0 : PyErr_Clear();
224 [ + - ]: 47 : else if (PyUnicode_Check(w)) {
225 : 47 : ps2 = PyUnicode_AsUTF8(w);
226 [ - + ]: 47 : if (ps2 == NULL) {
227 : 0 : PyErr_Clear();
228 : 0 : ps2 = "";
229 : : }
230 : : }
231 : : }
232 : 47 : arena = _PyArena_New();
233 [ + + ]: 47 : if (arena == NULL) {
234 : 17 : Py_XDECREF(v);
235 : 17 : Py_XDECREF(w);
236 : 17 : Py_XDECREF(oenc);
237 : 17 : return -1;
238 : : }
239 : :
240 : 30 : mod = _PyParser_ASTFromFile(fp, filename, enc, Py_single_input,
241 : : ps1, ps2, flags, &errcode, arena);
242 : :
243 : 30 : Py_XDECREF(v);
244 : 30 : Py_XDECREF(w);
245 : 30 : Py_XDECREF(oenc);
246 [ + + ]: 30 : if (mod == NULL) {
247 : 8 : _PyArena_Free(arena);
248 [ + + ]: 8 : if (errcode == E_EOF) {
249 : 7 : PyErr_Clear();
250 : 7 : return E_EOF;
251 : : }
252 : 1 : return -1;
253 : : }
254 : 22 : m = PyImport_AddModuleObject(&_Py_ID(__main__));
255 [ - + ]: 22 : if (m == NULL) {
256 : 0 : _PyArena_Free(arena);
257 : 0 : return -1;
258 : : }
259 : 22 : d = PyModule_GetDict(m);
260 : 22 : v = run_mod(mod, filename, d, d, flags, arena);
261 : 22 : _PyArena_Free(arena);
262 [ + + ]: 22 : if (v == NULL) {
263 : 7 : return -1;
264 : : }
265 : 15 : Py_DECREF(v);
266 : 15 : flush_io();
267 : 15 : return 0;
268 : : }
269 : :
270 : : int
271 : 0 : PyRun_InteractiveOneObject(FILE *fp, PyObject *filename, PyCompilerFlags *flags)
272 : : {
273 : : int res;
274 : :
275 : 0 : res = PyRun_InteractiveOneObjectEx(fp, filename, flags);
276 [ # # ]: 0 : if (res == -1) {
277 : 0 : PyErr_Print();
278 : 0 : flush_io();
279 : : }
280 : 0 : return res;
281 : : }
282 : :
283 : : int
284 : 0 : PyRun_InteractiveOneFlags(FILE *fp, const char *filename_str, PyCompilerFlags *flags)
285 : : {
286 : : PyObject *filename;
287 : : int res;
288 : :
289 : 0 : filename = PyUnicode_DecodeFSDefault(filename_str);
290 [ # # ]: 0 : if (filename == NULL) {
291 : 0 : PyErr_Print();
292 : 0 : return -1;
293 : : }
294 : 0 : res = PyRun_InteractiveOneObject(fp, filename, flags);
295 : 0 : Py_DECREF(filename);
296 : 0 : return res;
297 : : }
298 : :
299 : :
300 : : /* Check whether a file maybe a pyc file: Look at the extension,
301 : : the file type, and, if we may close it, at the first few bytes. */
302 : :
303 : : static int
304 : 356 : maybe_pyc_file(FILE *fp, PyObject *filename, int closeit)
305 : : {
306 : 356 : PyObject *ext = PyUnicode_FromString(".pyc");
307 [ - + ]: 356 : if (ext == NULL) {
308 : 0 : return -1;
309 : : }
310 : 356 : Py_ssize_t endswith = PyUnicode_Tailmatch(filename, ext, 0, PY_SSIZE_T_MAX, +1);
311 : 356 : Py_DECREF(ext);
312 [ + + ]: 356 : if (endswith) {
313 : 28 : return 1;
314 : : }
315 : :
316 : : /* Only look into the file if we are allowed to close it, since
317 : : it then should also be seekable. */
318 [ + + ]: 328 : if (!closeit) {
319 : 18 : return 0;
320 : : }
321 : :
322 : : /* Read only two bytes of the magic. If the file was opened in
323 : : text mode, the bytes 3 and 4 of the magic (\r\n) might not
324 : : be read as they are on disk. */
325 : 310 : unsigned int halfmagic = PyImport_GetMagicNumber() & 0xFFFF;
326 : : unsigned char buf[2];
327 : : /* Mess: In case of -x, the stream is NOT at its start now,
328 : : and ungetc() was used to push back the first newline,
329 : : which makes the current stream position formally undefined,
330 : : and a x-platform nightmare.
331 : : Unfortunately, we have no direct way to know whether -x
332 : : was specified. So we use a terrible hack: if the current
333 : : stream position is not 0, we assume -x was specified, and
334 : : give up. Bug 132850 on SourceForge spells out the
335 : : hopelessness of trying anything else (fseek and ftell
336 : : don't work predictably x-platform for text-mode files).
337 : : */
338 : 310 : int ispyc = 0;
339 [ + - ]: 310 : if (ftell(fp) == 0) {
340 [ + + ]: 310 : if (fread(buf, 1, 2, fp) == 2 &&
341 [ - + ]: 308 : ((unsigned int)buf[1]<<8 | buf[0]) == halfmagic)
342 : 0 : ispyc = 1;
343 : 310 : rewind(fp);
344 : : }
345 : 310 : return ispyc;
346 : : }
347 : :
348 : :
349 : : static int
350 : 343 : set_main_loader(PyObject *d, PyObject *filename, const char *loader_name)
351 : : {
352 : 343 : PyInterpreterState *interp = _PyInterpreterState_GET();
353 : 343 : PyObject *bootstrap = PyObject_GetAttrString(interp->importlib,
354 : : "_bootstrap_external");
355 [ - + ]: 343 : if (bootstrap == NULL) {
356 : 0 : return -1;
357 : : }
358 : :
359 : 343 : PyObject *loader_type = PyObject_GetAttrString(bootstrap, loader_name);
360 : 343 : Py_DECREF(bootstrap);
361 [ - + ]: 343 : if (loader_type == NULL) {
362 : 0 : return -1;
363 : : }
364 : :
365 : 343 : PyObject *loader = PyObject_CallFunction(loader_type,
366 : : "sO", "__main__", filename);
367 : 343 : Py_DECREF(loader_type);
368 [ - + ]: 343 : if (loader == NULL) {
369 : 0 : return -1;
370 : : }
371 : :
372 [ - + ]: 343 : if (PyDict_SetItemString(d, "__loader__", loader) < 0) {
373 : 0 : Py_DECREF(loader);
374 : 0 : return -1;
375 : : }
376 : 343 : Py_DECREF(loader);
377 : 343 : return 0;
378 : : }
379 : :
380 : :
381 : : int
382 : 356 : _PyRun_SimpleFileObject(FILE *fp, PyObject *filename, int closeit,
383 : : PyCompilerFlags *flags)
384 : : {
385 : : PyObject *m, *d, *v;
386 : 356 : int set_file_name = 0, ret = -1;
387 : :
388 : 356 : m = PyImport_AddModule("__main__");
389 [ - + ]: 356 : if (m == NULL)
390 : 0 : return -1;
391 : 356 : Py_INCREF(m);
392 : 356 : d = PyModule_GetDict(m);
393 [ + - ]: 356 : if (_PyDict_GetItemStringWithError(d, "__file__") == NULL) {
394 [ - + ]: 356 : if (PyErr_Occurred()) {
395 : 0 : goto done;
396 : : }
397 [ - + ]: 356 : if (PyDict_SetItemString(d, "__file__", filename) < 0) {
398 : 0 : goto done;
399 : : }
400 [ - + ]: 356 : if (PyDict_SetItemString(d, "__cached__", Py_None) < 0) {
401 : 0 : goto done;
402 : : }
403 : 356 : set_file_name = 1;
404 : : }
405 : :
406 : 356 : int pyc = maybe_pyc_file(fp, filename, closeit);
407 [ - + ]: 356 : if (pyc < 0) {
408 : 0 : goto done;
409 : : }
410 : :
411 [ + + ]: 356 : if (pyc) {
412 : : FILE *pyc_fp;
413 : : /* Try to run a pyc file. First, re-open in binary */
414 [ + - ]: 28 : if (closeit) {
415 : 28 : fclose(fp);
416 : : }
417 : :
418 : 28 : pyc_fp = _Py_fopen_obj(filename, "rb");
419 [ - + ]: 28 : if (pyc_fp == NULL) {
420 : 0 : fprintf(stderr, "python: Can't reopen .pyc file\n");
421 : 0 : goto done;
422 : : }
423 : :
424 [ - + ]: 28 : if (set_main_loader(d, filename, "SourcelessFileLoader") < 0) {
425 : 0 : fprintf(stderr, "python: failed to set __main__.__loader__\n");
426 : 0 : ret = -1;
427 : 0 : fclose(pyc_fp);
428 : 0 : goto done;
429 : : }
430 : 28 : v = run_pyc_file(pyc_fp, d, d, flags);
431 : : } else {
432 : : /* When running from stdin, leave __main__.__loader__ alone */
433 [ + + - + ]: 643 : if (PyUnicode_CompareWithASCIIString(filename, "<stdin>") != 0 &&
434 : 315 : set_main_loader(d, filename, "SourceFileLoader") < 0) {
435 : 0 : fprintf(stderr, "python: failed to set __main__.__loader__\n");
436 : 0 : ret = -1;
437 : 0 : goto done;
438 : : }
439 : 328 : v = pyrun_file(fp, filename, Py_file_input, d, d,
440 : : closeit, flags);
441 : : }
442 : 356 : flush_io();
443 [ + + ]: 356 : if (v == NULL) {
444 [ + - ]: 109 : Py_CLEAR(m);
445 : 109 : PyErr_Print();
446 : 62 : goto done;
447 : : }
448 : 247 : Py_DECREF(v);
449 : 247 : ret = 0;
450 : 309 : done:
451 [ + - ]: 309 : if (set_file_name) {
452 [ - + ]: 309 : if (PyDict_DelItemString(d, "__file__")) {
453 : 0 : PyErr_Clear();
454 : : }
455 [ - + ]: 309 : if (PyDict_DelItemString(d, "__cached__")) {
456 : 0 : PyErr_Clear();
457 : : }
458 : : }
459 : 309 : Py_XDECREF(m);
460 : 309 : return ret;
461 : : }
462 : :
463 : :
464 : : int
465 : 0 : PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit,
466 : : PyCompilerFlags *flags)
467 : : {
468 : 0 : PyObject *filename_obj = PyUnicode_DecodeFSDefault(filename);
469 [ # # ]: 0 : if (filename_obj == NULL) {
470 : 0 : return -1;
471 : : }
472 : 0 : int res = _PyRun_SimpleFileObject(fp, filename_obj, closeit, flags);
473 : 0 : Py_DECREF(filename_obj);
474 : 0 : return res;
475 : : }
476 : :
477 : :
478 : : int
479 : 1740 : PyRun_SimpleStringFlags(const char *command, PyCompilerFlags *flags)
480 : : {
481 : : PyObject *m, *d, *v;
482 : 1740 : m = PyImport_AddModule("__main__");
483 [ - + ]: 1740 : if (m == NULL)
484 : 0 : return -1;
485 : 1740 : d = PyModule_GetDict(m);
486 : 1740 : v = PyRun_StringFlags(command, Py_file_input, d, d, flags);
487 [ + + ]: 1738 : if (v == NULL) {
488 : 741 : PyErr_Print();
489 : 50 : return -1;
490 : : }
491 : 997 : Py_DECREF(v);
492 : 997 : return 0;
493 : : }
494 : :
495 : : static int
496 : 66 : parse_syntax_error(PyObject *err, PyObject **message, PyObject **filename,
497 : : Py_ssize_t *lineno, Py_ssize_t *offset,
498 : : Py_ssize_t* end_lineno, Py_ssize_t* end_offset,
499 : : PyObject **text)
500 : : {
501 : : Py_ssize_t hold;
502 : : PyObject *v;
503 : :
504 : 66 : *message = NULL;
505 : 66 : *filename = NULL;
506 : :
507 : : /* new style errors. `err' is an instance */
508 : 66 : *message = PyObject_GetAttr(err, &_Py_ID(msg));
509 [ - + ]: 66 : if (!*message)
510 : 0 : goto finally;
511 : :
512 : 66 : v = PyObject_GetAttr(err, &_Py_ID(filename));
513 [ - + ]: 66 : if (!v)
514 : 0 : goto finally;
515 [ + + ]: 66 : if (v == Py_None) {
516 : 5 : Py_DECREF(v);
517 : : _Py_DECLARE_STR(anon_string, "<string>");
518 : 5 : *filename = &_Py_STR(anon_string);
519 : 5 : Py_INCREF(*filename);
520 : : }
521 : : else {
522 : 61 : *filename = v;
523 : : }
524 : :
525 : 66 : v = PyObject_GetAttr(err, &_Py_ID(lineno));
526 [ - + ]: 66 : if (!v)
527 : 0 : goto finally;
528 : 66 : hold = PyLong_AsSsize_t(v);
529 : 66 : Py_DECREF(v);
530 [ + + + - ]: 66 : if (hold < 0 && PyErr_Occurred())
531 : 5 : goto finally;
532 : 61 : *lineno = hold;
533 : :
534 : 61 : v = PyObject_GetAttr(err, &_Py_ID(offset));
535 [ - + ]: 61 : if (!v)
536 : 0 : goto finally;
537 [ + + ]: 61 : if (v == Py_None) {
538 : 2 : *offset = -1;
539 : 2 : Py_DECREF(v);
540 : : } else {
541 : 59 : hold = PyLong_AsSsize_t(v);
542 : 59 : Py_DECREF(v);
543 [ + + - + ]: 59 : if (hold < 0 && PyErr_Occurred())
544 : 0 : goto finally;
545 : 59 : *offset = hold;
546 : : }
547 : :
548 [ + - ]: 61 : if (Py_TYPE(err) == (PyTypeObject*)PyExc_SyntaxError) {
549 : 61 : v = PyObject_GetAttr(err, &_Py_ID(end_lineno));
550 [ - + ]: 61 : if (!v) {
551 : 0 : PyErr_Clear();
552 : 0 : *end_lineno = *lineno;
553 : : }
554 [ + + ]: 61 : else if (v == Py_None) {
555 : 34 : *end_lineno = *lineno;
556 : 34 : Py_DECREF(v);
557 : : } else {
558 : 27 : hold = PyLong_AsSsize_t(v);
559 : 27 : Py_DECREF(v);
560 [ - + - - ]: 27 : if (hold < 0 && PyErr_Occurred())
561 : 0 : goto finally;
562 : 27 : *end_lineno = hold;
563 : : }
564 : :
565 : 61 : v = PyObject_GetAttr(err, &_Py_ID(end_offset));
566 [ - + ]: 61 : if (!v) {
567 : 0 : PyErr_Clear();
568 : 0 : *end_offset = -1;
569 : : }
570 [ + + ]: 61 : else if (v == Py_None) {
571 : 34 : *end_offset = -1;
572 : 34 : Py_DECREF(v);
573 : : } else {
574 : 27 : hold = PyLong_AsSsize_t(v);
575 : 27 : Py_DECREF(v);
576 [ + + - + ]: 27 : if (hold < 0 && PyErr_Occurred())
577 : 0 : goto finally;
578 : 27 : *end_offset = hold;
579 : : }
580 : : } else {
581 : : // SyntaxError subclasses
582 : 0 : *end_lineno = *lineno;
583 : 0 : *end_offset = -1;
584 : : }
585 : :
586 : 61 : v = PyObject_GetAttr(err, &_Py_ID(text));
587 [ - + ]: 61 : if (!v)
588 : 0 : goto finally;
589 [ + + ]: 61 : if (v == Py_None) {
590 : 2 : Py_DECREF(v);
591 : 2 : *text = NULL;
592 : : }
593 : : else {
594 : 59 : *text = v;
595 : : }
596 : 61 : return 1;
597 : :
598 : 5 : finally:
599 : 5 : Py_XDECREF(*message);
600 : 5 : Py_XDECREF(*filename);
601 : 5 : return 0;
602 : : }
603 : :
604 : : static int
605 : 59 : print_error_text(PyObject *f, Py_ssize_t offset, Py_ssize_t end_offset,
606 : : PyObject *text_obj)
607 : : {
608 [ + + ]: 18 : size_t caret_repetitions = (end_offset > 0 && end_offset > offset) ?
609 [ + + ]: 77 : end_offset - offset : 1;
610 : :
611 : : /* Convert text to a char pointer; return if error */
612 : 59 : const char *text = PyUnicode_AsUTF8(text_obj);
613 [ - + ]: 59 : if (text == NULL) {
614 : 0 : return -1;
615 : : }
616 : :
617 : : /* Convert offset from 1-based to 0-based */
618 : 59 : offset--;
619 : :
620 : : /* Strip leading whitespace from text, adjusting offset as we go */
621 [ + + - + : 102 : while (*text == ' ' || *text == '\t' || *text == '\f') {
+ + ]
622 : 43 : text++;
623 : 43 : offset--;
624 : : }
625 : :
626 : : /* Calculate text length excluding trailing newline */
627 : 59 : Py_ssize_t len = strlen(text);
628 [ + - + + ]: 59 : if (len > 0 && text[len-1] == '\n') {
629 : 9 : len--;
630 : : }
631 : :
632 : : /* Clip offset to at most len */
633 [ + + ]: 59 : if (offset > len) {
634 : 6 : offset = len;
635 : : }
636 : :
637 : : /* Skip past newlines embedded in text */
638 : 0 : for (;;) {
639 : 59 : const char *nl = strchr(text, '\n');
640 [ + + ]: 59 : if (nl == NULL) {
641 : 50 : break;
642 : : }
643 : 9 : Py_ssize_t inl = nl - text;
644 [ + - ]: 9 : if (inl >= offset) {
645 : 9 : break;
646 : : }
647 : 0 : inl += 1;
648 : 0 : text += inl;
649 : 0 : len -= inl;
650 : 0 : offset -= (int)inl;
651 : : }
652 : :
653 : : /* Print text */
654 [ - + ]: 59 : if (PyFile_WriteString(" ", f) < 0) {
655 : 0 : return -1;
656 : : }
657 [ - + ]: 59 : if (PyFile_WriteString(text, f) < 0) {
658 : 0 : return -1;
659 : : }
660 : :
661 : : /* Make sure there's a newline at the end */
662 [ + + ]: 59 : if (text[len] != '\n') {
663 [ - + ]: 50 : if (PyFile_WriteString("\n", f) < 0) {
664 : 0 : return -1;
665 : : }
666 : : }
667 : :
668 : : /* Don't print caret if it points to the left of the text */
669 [ + + ]: 59 : if (offset < 0) {
670 : 18 : return 0;
671 : : }
672 : :
673 : : /* Write caret line */
674 [ - + ]: 41 : if (PyFile_WriteString(" ", f) < 0) {
675 : 0 : return -1;
676 : : }
677 [ + + ]: 200 : while (--offset >= 0) {
678 [ - + ]: 159 : if (PyFile_WriteString(" ", f) < 0) {
679 : 0 : return -1;
680 : : }
681 : : }
682 [ + + ]: 134 : for (size_t caret_iter=0; caret_iter < caret_repetitions ; caret_iter++) {
683 [ - + ]: 93 : if (PyFile_WriteString("^", f) < 0) {
684 : 0 : return -1;
685 : : }
686 : : }
687 [ - + ]: 41 : if (PyFile_WriteString("\n", f) < 0) {
688 : 0 : return -1;
689 : : }
690 : 41 : return 0;
691 : : }
692 : :
693 : :
694 : : int
695 : 1634 : _Py_HandleSystemExit(int *exitcode_p)
696 : : {
697 : 1634 : int inspect = _Py_GetConfig()->inspect;
698 [ + + ]: 1634 : if (inspect) {
699 : : /* Don't exit if -i flag was given. This flag is set to 0
700 : : * when entering interactive mode for inspecting. */
701 : 2 : return 0;
702 : : }
703 : :
704 [ + + ]: 1632 : if (!PyErr_ExceptionMatches(PyExc_SystemExit)) {
705 : 178 : return 0;
706 : : }
707 : :
708 : : PyObject *exception, *value, *tb;
709 : 1454 : PyErr_Fetch(&exception, &value, &tb);
710 : :
711 : 1454 : fflush(stdout);
712 : :
713 : 1454 : int exitcode = 0;
714 [ + - + + ]: 1454 : if (value == NULL || value == Py_None) {
715 : 2 : goto done;
716 : : }
717 : :
718 [ + + ]: 1452 : if (PyExceptionInstance_Check(value)) {
719 : : /* The error code should be in the `code' attribute. */
720 : 635 : PyObject *code = PyObject_GetAttr(value, &_Py_ID(code));
721 [ + + ]: 635 : if (code) {
722 : 634 : Py_DECREF(value);
723 : 634 : value = code;
724 [ + + ]: 634 : if (value == Py_None)
725 : 40 : goto done;
726 : : }
727 : : /* If we failed to dig out the 'code' attribute,
728 : : just let the else clause below print the error. */
729 : : }
730 : :
731 [ + + ]: 1412 : if (PyLong_Check(value)) {
732 : 1391 : exitcode = (int)PyLong_AsLong(value);
733 : : }
734 : : else {
735 : 21 : PyThreadState *tstate = _PyThreadState_GET();
736 : 21 : PyObject *sys_stderr = _PySys_GetAttr(tstate, &_Py_ID(stderr));
737 : : /* We clear the exception here to avoid triggering the assertion
738 : : * in PyObject_Str that ensures it won't silently lose exception
739 : : * details.
740 : : */
741 : 21 : PyErr_Clear();
742 [ + - + - ]: 21 : if (sys_stderr != NULL && sys_stderr != Py_None) {
743 : 21 : PyFile_WriteObject(value, sys_stderr, Py_PRINT_RAW);
744 : : } else {
745 : 0 : PyObject_Print(value, stderr, Py_PRINT_RAW);
746 : 0 : fflush(stderr);
747 : : }
748 : 21 : PySys_WriteStderr("\n");
749 : 21 : exitcode = 1;
750 : : }
751 : :
752 : 1454 : done:
753 : : /* Restore and clear the exception info, in order to properly decref
754 : : * the exception, value, and traceback. If we just exit instead,
755 : : * these leak, which confuses PYTHONDUMPREFS output, and may prevent
756 : : * some finalizers from running.
757 : : */
758 : 1454 : PyErr_Restore(exception, value, tb);
759 : 1454 : PyErr_Clear();
760 : 1454 : *exitcode_p = exitcode;
761 : 1454 : return 1;
762 : : }
763 : :
764 : :
765 : : static void
766 : 898 : handle_system_exit(void)
767 : : {
768 : : int exitcode;
769 [ + + ]: 898 : if (_Py_HandleSystemExit(&exitcode)) {
770 : 742 : Py_Exit(exitcode);
771 : : }
772 : 156 : }
773 : :
774 : :
775 : : static void
776 : 898 : _PyErr_PrintEx(PyThreadState *tstate, int set_sys_last_vars)
777 : : {
778 : : PyObject *exception, *v, *tb, *hook;
779 : :
780 : 898 : handle_system_exit();
781 : :
782 : 156 : _PyErr_Fetch(tstate, &exception, &v, &tb);
783 [ - + ]: 156 : if (exception == NULL) {
784 : 0 : goto done;
785 : : }
786 : :
787 : 156 : _PyErr_NormalizeException(tstate, &exception, &v, &tb);
788 [ + + ]: 156 : if (tb == NULL) {
789 : 57 : tb = Py_None;
790 : 57 : Py_INCREF(tb);
791 : : }
792 : 156 : PyException_SetTraceback(v, tb);
793 [ - + ]: 156 : if (exception == NULL) {
794 : 0 : goto done;
795 : : }
796 : :
797 : : /* Now we know v != NULL too */
798 [ + - ]: 156 : if (set_sys_last_vars) {
799 [ - + ]: 156 : if (_PySys_SetAttr(&_Py_ID(last_type), exception) < 0) {
800 : 0 : _PyErr_Clear(tstate);
801 : : }
802 [ - + ]: 156 : if (_PySys_SetAttr(&_Py_ID(last_value), v) < 0) {
803 : 0 : _PyErr_Clear(tstate);
804 : : }
805 [ - + ]: 156 : if (_PySys_SetAttr(&_Py_ID(last_traceback), tb) < 0) {
806 : 0 : _PyErr_Clear(tstate);
807 : : }
808 : : }
809 : 156 : hook = _PySys_GetAttr(tstate, &_Py_ID(excepthook));
810 [ + - - + ]: 156 : if (_PySys_Audit(tstate, "sys.excepthook", "OOOO", hook ? hook : Py_None,
811 : : exception, v, tb) < 0) {
812 [ # # ]: 0 : if (PyErr_ExceptionMatches(PyExc_RuntimeError)) {
813 : 0 : PyErr_Clear();
814 : 0 : goto done;
815 : : }
816 : 0 : _PyErr_WriteUnraisableMsg("in audit hook", NULL);
817 : : }
818 [ + - ]: 156 : if (hook) {
819 : : PyObject* stack[3];
820 : : PyObject *result;
821 : :
822 : 156 : stack[0] = exception;
823 : 156 : stack[1] = v;
824 : 156 : stack[2] = tb;
825 : 156 : result = _PyObject_FastCall(hook, stack, 3);
826 [ - + ]: 156 : if (result == NULL) {
827 : 0 : handle_system_exit();
828 : :
829 : : PyObject *exception2, *v2, *tb2;
830 : 0 : _PyErr_Fetch(tstate, &exception2, &v2, &tb2);
831 : 0 : _PyErr_NormalizeException(tstate, &exception2, &v2, &tb2);
832 : : /* It should not be possible for exception2 or v2
833 : : to be NULL. However PyErr_Display() can't
834 : : tolerate NULLs, so just be safe. */
835 [ # # ]: 0 : if (exception2 == NULL) {
836 : 0 : exception2 = Py_None;
837 : 0 : Py_INCREF(exception2);
838 : : }
839 [ # # ]: 0 : if (v2 == NULL) {
840 : 0 : v2 = Py_None;
841 : 0 : Py_INCREF(v2);
842 : : }
843 : 0 : fflush(stdout);
844 : 0 : PySys_WriteStderr("Error in sys.excepthook:\n");
845 : 0 : PyErr_Display(exception2, v2, tb2);
846 : 0 : PySys_WriteStderr("\nOriginal exception was:\n");
847 : 0 : PyErr_Display(exception, v, tb);
848 : 0 : Py_DECREF(exception2);
849 : 0 : Py_DECREF(v2);
850 : 0 : Py_XDECREF(tb2);
851 : : }
852 : 156 : Py_XDECREF(result);
853 : : }
854 : : else {
855 : 0 : PySys_WriteStderr("sys.excepthook is missing\n");
856 : 0 : PyErr_Display(exception, v, tb);
857 : : }
858 : :
859 : 156 : done:
860 : 156 : Py_XDECREF(exception);
861 : 156 : Py_XDECREF(v);
862 : 156 : Py_XDECREF(tb);
863 : 156 : }
864 : :
865 : : void
866 : 0 : _PyErr_Print(PyThreadState *tstate)
867 : : {
868 : 0 : _PyErr_PrintEx(tstate, 1);
869 : 0 : }
870 : :
871 : : void
872 : 898 : PyErr_PrintEx(int set_sys_last_vars)
873 : : {
874 : 898 : PyThreadState *tstate = _PyThreadState_GET();
875 : 898 : _PyErr_PrintEx(tstate, set_sys_last_vars);
876 : 156 : }
877 : :
878 : : void
879 : 898 : PyErr_Print(void)
880 : : {
881 : 898 : PyErr_PrintEx(1);
882 : 156 : }
883 : :
884 : : struct exception_print_context
885 : : {
886 : : PyObject *file;
887 : : PyObject *seen; // Prevent cycles in recursion
888 : : int exception_group_depth; // nesting level of current exception group
889 : : bool need_close; // Need a closing bottom frame
890 : : int max_group_width; // Maximum number of children of each EG
891 : : int max_group_depth; // Maximum nesting level of EGs
892 : : };
893 : :
894 : : #define EXC_MARGIN(ctx) ((ctx)->exception_group_depth ? "| " : "")
895 : : #define EXC_INDENT(ctx) (2 * (ctx)->exception_group_depth)
896 : :
897 : : static int
898 : 600 : write_indented_margin(struct exception_print_context *ctx, PyObject *f)
899 : : {
900 [ + + ]: 600 : return _Py_WriteIndentedMargin(EXC_INDENT(ctx), EXC_MARGIN(ctx), f);
901 : : }
902 : :
903 : : static int
904 : 2 : print_exception_invalid_type(struct exception_print_context *ctx,
905 : : PyObject *value)
906 : : {
907 : 2 : PyObject *f = ctx->file;
908 [ - + ]: 2 : if (_Py_WriteIndent(EXC_INDENT(ctx), f) < 0) {
909 : 0 : return -1;
910 : : }
911 : 2 : const char *const msg = "TypeError: print_exception(): Exception expected "
912 : : "for value, ";
913 [ - + ]: 2 : if (PyFile_WriteString(msg, f) < 0) {
914 : 0 : return -1;
915 : : }
916 [ - + ]: 2 : if (PyFile_WriteString(Py_TYPE(value)->tp_name, f) < 0) {
917 : 0 : return -1;
918 : : }
919 [ - + ]: 2 : if (PyFile_WriteString(" found\n", f) < 0) {
920 : 0 : return -1;
921 : : }
922 : 2 : return 0;
923 : : }
924 : :
925 : : static int
926 : 439 : print_exception_traceback(struct exception_print_context *ctx, PyObject *value)
927 : : {
928 : 439 : PyObject *f = ctx->file;
929 : 439 : int err = 0;
930 : :
931 : 439 : PyObject *tb = PyException_GetTraceback(value);
932 [ + + + + ]: 439 : if (tb && tb != Py_None) {
933 : 241 : const char *header = EXCEPTION_TB_HEADER;
934 [ + + ]: 241 : const char *header_margin = EXC_MARGIN(ctx);
935 [ + + ]: 241 : if (_PyBaseExceptionGroup_Check(value)) {
936 : 11 : header = EXCEPTION_GROUP_TB_HEADER;
937 [ + + ]: 11 : if (ctx->exception_group_depth == 1) {
938 : 10 : header_margin = "+ ";
939 : : }
940 : : }
941 : 241 : err = _PyTraceBack_Print_Indented(
942 [ + + ]: 482 : tb, EXC_INDENT(ctx), EXC_MARGIN(ctx), header_margin, header, f);
943 : : }
944 : 439 : Py_XDECREF(tb);
945 : 439 : return err;
946 : : }
947 : :
948 : : static int
949 : 439 : print_exception_file_and_line(struct exception_print_context *ctx,
950 : : PyObject **value_p)
951 : : {
952 : 439 : PyObject *f = ctx->file;
953 : :
954 : : PyObject *tmp;
955 : 439 : int res = _PyObject_LookupAttr(*value_p, &_Py_ID(print_file_and_line), &tmp);
956 [ + + ]: 439 : if (res <= 0) {
957 [ - + ]: 373 : if (res < 0) {
958 : 0 : PyErr_Clear();
959 : : }
960 : 373 : return 0;
961 : : }
962 : 66 : Py_DECREF(tmp);
963 : :
964 : : PyObject *message, *filename, *text;
965 : : Py_ssize_t lineno, offset, end_lineno, end_offset;
966 [ + + ]: 66 : if (!parse_syntax_error(*value_p, &message, &filename,
967 : : &lineno, &offset,
968 : : &end_lineno, &end_offset, &text)) {
969 : 5 : PyErr_Clear();
970 : 5 : return 0;
971 : : }
972 : :
973 : 61 : Py_SETREF(*value_p, message);
974 : :
975 : 61 : PyObject *line = PyUnicode_FromFormat(" File \"%S\", line %zd\n",
976 : : filename, lineno);
977 : 61 : Py_DECREF(filename);
978 [ - + ]: 61 : if (line == NULL) {
979 : 0 : goto error;
980 : : }
981 [ - + ]: 61 : if (write_indented_margin(ctx, f) < 0) {
982 : 0 : goto error;
983 : : }
984 [ - + ]: 61 : if (PyFile_WriteObject(line, f, Py_PRINT_RAW) < 0) {
985 : 0 : goto error;
986 : : }
987 [ + - ]: 61 : Py_CLEAR(line);
988 : :
989 [ + + ]: 61 : if (text != NULL) {
990 : : Py_ssize_t line_size;
991 : 59 : const char *error_line = PyUnicode_AsUTF8AndSize(text, &line_size);
992 : : // If the location of the error spawn multiple lines, we want
993 : : // to just print the first one and highlight everything until
994 : : // the end of that one since we don't support multi-line error
995 : : // messages.
996 [ + + ]: 59 : if (end_lineno > lineno) {
997 [ + - ]: 1 : end_offset = (error_line != NULL) ? line_size : -1;
998 : : }
999 : : // Limit the amount of '^' that we can display to
1000 : : // the size of the text in the source line.
1001 [ + - + + ]: 59 : if (error_line != NULL && end_offset > line_size + 1) {
1002 : 1 : end_offset = line_size + 1;
1003 : : }
1004 [ - + ]: 59 : if (print_error_text(f, offset, end_offset, text) < 0) {
1005 : 0 : goto error;
1006 : : }
1007 : 59 : Py_DECREF(text);
1008 : : }
1009 : : assert(!PyErr_Occurred());
1010 : 61 : return 0;
1011 : :
1012 : 0 : error:
1013 : 0 : Py_XDECREF(line);
1014 : 0 : Py_XDECREF(text);
1015 : 0 : return -1;
1016 : : }
1017 : :
1018 : : /* Prints the message line: module.qualname[: str(exc)] */
1019 : : static int
1020 : 439 : print_exception_message(struct exception_print_context *ctx, PyObject *type,
1021 : : PyObject *value)
1022 : : {
1023 : 439 : PyObject *f = ctx->file;
1024 : :
1025 : : assert(PyExceptionClass_Check(type));
1026 : :
1027 [ + + ]: 439 : if (write_indented_margin(ctx, f) < 0) {
1028 : 33 : return -1;
1029 : : }
1030 : 406 : PyObject *modulename = PyObject_GetAttr(type, &_Py_ID(__module__));
1031 [ + - + + ]: 406 : if (modulename == NULL || !PyUnicode_Check(modulename)) {
1032 : 1 : Py_XDECREF(modulename);
1033 : 1 : PyErr_Clear();
1034 [ - + ]: 1 : if (PyFile_WriteString("<unknown>.", f) < 0) {
1035 : 0 : return -1;
1036 : : }
1037 : : }
1038 : : else {
1039 [ + + + + ]: 421 : if (!_PyUnicode_Equal(modulename, &_Py_ID(builtins)) &&
1040 : 16 : !_PyUnicode_Equal(modulename, &_Py_ID(__main__)))
1041 : 14 : {
1042 : 14 : int res = PyFile_WriteObject(modulename, f, Py_PRINT_RAW);
1043 : 14 : Py_DECREF(modulename);
1044 [ - + ]: 14 : if (res < 0) {
1045 : 0 : return -1;
1046 : : }
1047 [ - + ]: 14 : if (PyFile_WriteString(".", f) < 0) {
1048 : 0 : return -1;
1049 : : }
1050 : : }
1051 : : else {
1052 : 391 : Py_DECREF(modulename);
1053 : : }
1054 : : }
1055 : :
1056 : 406 : PyObject *qualname = PyType_GetQualName((PyTypeObject *)type);
1057 [ + - - + ]: 406 : if (qualname == NULL || !PyUnicode_Check(qualname)) {
1058 : 0 : Py_XDECREF(qualname);
1059 : 0 : PyErr_Clear();
1060 [ # # ]: 0 : if (PyFile_WriteString("<unknown>", f) < 0) {
1061 : 0 : return -1;
1062 : : }
1063 : : }
1064 : : else {
1065 : 406 : int res = PyFile_WriteObject(qualname, f, Py_PRINT_RAW);
1066 : 406 : Py_DECREF(qualname);
1067 [ - + ]: 406 : if (res < 0) {
1068 : 0 : return -1;
1069 : : }
1070 : : }
1071 : :
1072 [ - + ]: 406 : if (Py_IsNone(value)) {
1073 : 0 : return 0;
1074 : : }
1075 : :
1076 : 406 : PyObject *s = PyObject_Str(value);
1077 [ + + ]: 406 : if (s == NULL) {
1078 : 3 : PyErr_Clear();
1079 [ - + ]: 3 : if (PyFile_WriteString(": <exception str() failed>", f) < 0) {
1080 : 0 : return -1;
1081 : : }
1082 : : }
1083 : : else {
1084 : : /* only print colon if the str() of the
1085 : : object is not the empty string
1086 : : */
1087 [ + - + + ]: 403 : if (!PyUnicode_Check(s) || PyUnicode_GetLength(s) != 0) {
1088 [ - + ]: 372 : if (PyFile_WriteString(": ", f) < 0) {
1089 : 0 : Py_DECREF(s);
1090 : 0 : return -1;
1091 : : }
1092 : : }
1093 : 403 : int res = PyFile_WriteObject(s, f, Py_PRINT_RAW);
1094 : 403 : Py_DECREF(s);
1095 [ - + ]: 403 : if (res < 0) {
1096 : 0 : return -1;
1097 : : }
1098 : : }
1099 : :
1100 : 406 : return 0;
1101 : : }
1102 : :
1103 : : static int
1104 : 406 : print_exception_suggestions(struct exception_print_context *ctx,
1105 : : PyObject *value)
1106 : : {
1107 : 406 : PyObject *f = ctx->file;
1108 : 406 : PyObject *suggestions = _Py_Offer_Suggestions(value);
1109 [ + + ]: 406 : if (suggestions) {
1110 : : // Add a trailer ". Did you mean: (...)?"
1111 [ - + ]: 28 : if (PyFile_WriteString(". Did you mean: '", f) < 0) {
1112 : 0 : goto error;
1113 : : }
1114 [ - + ]: 28 : if (PyFile_WriteObject(suggestions, f, Py_PRINT_RAW) < 0) {
1115 : 0 : goto error;
1116 : : }
1117 [ - + ]: 28 : if (PyFile_WriteString("'?", f) < 0) {
1118 : 0 : goto error;
1119 : : }
1120 : 28 : Py_DECREF(suggestions);
1121 : : }
1122 [ + + ]: 378 : else if (PyErr_Occurred()) {
1123 : 1 : PyErr_Clear();
1124 : : }
1125 : 406 : return 0;
1126 : 0 : error:
1127 : 0 : Py_XDECREF(suggestions);
1128 : 0 : return -1;
1129 : : }
1130 : :
1131 : : static int
1132 : 406 : print_exception_notes(struct exception_print_context *ctx, PyObject *value)
1133 : : {
1134 : 406 : PyObject *f = ctx->file;
1135 : :
1136 [ + + ]: 406 : if (!PyExceptionInstance_Check(value)) {
1137 : 61 : return 0;
1138 : : }
1139 : :
1140 [ + + ]: 345 : if (!PyObject_HasAttr(value, &_Py_ID(__notes__))) {
1141 : 330 : return 0;
1142 : : }
1143 : 15 : PyObject *notes = PyObject_GetAttr(value, &_Py_ID(__notes__));
1144 [ - + ]: 15 : if (notes == NULL) {
1145 : 0 : return -1;
1146 : : }
1147 [ + + ]: 15 : if (!PySequence_Check(notes)) {
1148 : 2 : int res = 0;
1149 [ - + ]: 2 : if (write_indented_margin(ctx, f) < 0) {
1150 : 0 : res = -1;
1151 : : }
1152 : 2 : PyObject *s = PyObject_Repr(notes);
1153 [ + + ]: 2 : if (s == NULL) {
1154 : 1 : PyErr_Clear();
1155 : 1 : res = PyFile_WriteString("<__notes__ repr() failed>", f);
1156 : : }
1157 : : else {
1158 : 1 : res = PyFile_WriteObject(s, f, Py_PRINT_RAW);
1159 : 1 : Py_DECREF(s);
1160 : : }
1161 : 2 : Py_DECREF(notes);
1162 : 2 : return res;
1163 : : }
1164 : 13 : Py_ssize_t num_notes = PySequence_Length(notes);
1165 : 13 : PyObject *lines = NULL;
1166 [ + + ]: 34 : for (Py_ssize_t ni = 0; ni < num_notes; ni++) {
1167 : 21 : PyObject *note = PySequence_GetItem(notes, ni);
1168 : 21 : PyObject *note_str = PyObject_Str(note);
1169 : 21 : Py_DECREF(note);
1170 : :
1171 [ + + ]: 21 : if (note_str == NULL) {
1172 : 1 : PyErr_Clear();
1173 [ - + ]: 1 : if (PyFile_WriteString("<note str() failed>", f) < 0) {
1174 : 0 : goto error;
1175 : : }
1176 : : }
1177 : : else {
1178 : 20 : lines = PyUnicode_Splitlines(note_str, 1);
1179 : 20 : Py_DECREF(note_str);
1180 : :
1181 [ - + ]: 20 : if (lines == NULL) {
1182 : 0 : goto error;
1183 : : }
1184 : :
1185 : 20 : Py_ssize_t n = PyList_GET_SIZE(lines);
1186 [ + + ]: 49 : for (Py_ssize_t i = 0; i < n; i++) {
1187 : 29 : PyObject *line = PyList_GET_ITEM(lines, i);
1188 : : assert(PyUnicode_Check(line));
1189 [ - + ]: 29 : if (write_indented_margin(ctx, f) < 0) {
1190 : 0 : goto error;
1191 : : }
1192 [ - + ]: 29 : if (PyFile_WriteObject(line, f, Py_PRINT_RAW) < 0) {
1193 : 0 : goto error;
1194 : : }
1195 : : }
1196 [ + - ]: 20 : Py_CLEAR(lines);
1197 : : }
1198 [ - + ]: 21 : if (PyFile_WriteString("\n", f) < 0) {
1199 : 0 : goto error;
1200 : : }
1201 : : }
1202 : :
1203 : 13 : Py_DECREF(notes);
1204 : 13 : return 0;
1205 : 0 : error:
1206 : 0 : Py_XDECREF(lines);
1207 : 0 : Py_DECREF(notes);
1208 : 0 : return -1;
1209 : : }
1210 : :
1211 : : static int
1212 : 441 : print_exception(struct exception_print_context *ctx, PyObject *value)
1213 : : {
1214 : 441 : PyObject *f = ctx->file;
1215 : :
1216 [ + + ]: 441 : if (!PyExceptionInstance_Check(value)) {
1217 : 2 : return print_exception_invalid_type(ctx, value);
1218 : : }
1219 : :
1220 : 439 : Py_INCREF(value);
1221 : 439 : fflush(stdout);
1222 : :
1223 [ - + ]: 439 : if (print_exception_traceback(ctx, value) < 0) {
1224 : 0 : goto error;
1225 : : }
1226 : :
1227 : : /* grab the type now because value can change below */
1228 : 439 : PyObject *type = (PyObject *) Py_TYPE(value);
1229 : :
1230 [ - + ]: 439 : if (print_exception_file_and_line(ctx, &value) < 0) {
1231 : 0 : goto error;
1232 : : }
1233 [ + + ]: 439 : if (print_exception_message(ctx, type, value) < 0) {
1234 : 33 : goto error;
1235 : : }
1236 [ - + ]: 406 : if (print_exception_suggestions(ctx, value) < 0) {
1237 : 0 : goto error;
1238 : : }
1239 [ - + ]: 406 : if (PyFile_WriteString("\n", f) < 0) {
1240 : 0 : goto error;
1241 : : }
1242 [ - + ]: 406 : if (print_exception_notes(ctx, value) < 0) {
1243 : 0 : goto error;
1244 : : }
1245 : :
1246 : 406 : Py_DECREF(value);
1247 : : assert(!PyErr_Occurred());
1248 : 406 : return 0;
1249 : 33 : error:
1250 : 33 : Py_DECREF(value);
1251 : 33 : return -1;
1252 : : }
1253 : :
1254 : : static const char cause_message[] =
1255 : : "The above exception was the direct cause "
1256 : : "of the following exception:\n";
1257 : :
1258 : : static const char context_message[] =
1259 : : "During handling of the above exception, "
1260 : : "another exception occurred:\n";
1261 : :
1262 : : static int
1263 : : print_exception_recursive(struct exception_print_context*, PyObject*);
1264 : :
1265 : : static int
1266 : 22 : print_chained(struct exception_print_context* ctx, PyObject *value,
1267 : : const char * message, const char *tag)
1268 : : {
1269 : 22 : PyObject *f = ctx->file;
1270 : :
1271 [ - + ]: 22 : if (_Py_EnterRecursiveCall(" in print_chained") < 0) {
1272 : 0 : return -1;
1273 : : }
1274 : 22 : bool need_close = ctx->need_close;
1275 : 22 : int res = print_exception_recursive(ctx, value);
1276 : 22 : ctx->need_close = need_close;
1277 : 22 : _Py_LeaveRecursiveCall();
1278 [ - + ]: 22 : if (res < 0) {
1279 : 0 : return -1;
1280 : : }
1281 : :
1282 [ - + ]: 22 : if (write_indented_margin(ctx, f) < 0) {
1283 : 0 : return -1;
1284 : : }
1285 [ - + ]: 22 : if (PyFile_WriteString("\n", f) < 0) {
1286 : 0 : return -1;
1287 : : }
1288 [ - + ]: 22 : if (write_indented_margin(ctx, f) < 0) {
1289 : 0 : return -1;
1290 : : }
1291 [ - + ]: 22 : if (PyFile_WriteString(message, f) < 0) {
1292 : 0 : return -1;
1293 : : }
1294 [ - + ]: 22 : if (write_indented_margin(ctx, f) < 0) {
1295 : 0 : return -1;
1296 : : }
1297 [ - + ]: 22 : if (PyFile_WriteString("\n", f) < 0) {
1298 : 0 : return -1;
1299 : : }
1300 : 22 : return 0;
1301 : : }
1302 : :
1303 : : /* Return true if value is in seen or there was a lookup error.
1304 : : * Return false if lookup succeeded and the item was not found.
1305 : : * We suppress errors because this makes us err on the side of
1306 : : * under-printing which is better than over-printing irregular
1307 : : * exceptions (e.g., unhashable ones).
1308 : : */
1309 : : static bool
1310 : 24 : print_exception_seen_lookup(struct exception_print_context *ctx,
1311 : : PyObject *value)
1312 : : {
1313 : 24 : PyObject *check_id = PyLong_FromVoidPtr(value);
1314 [ - + ]: 24 : if (check_id == NULL) {
1315 : 0 : PyErr_Clear();
1316 : 0 : return true;
1317 : : }
1318 : :
1319 : 24 : int in_seen = PySet_Contains(ctx->seen, check_id);
1320 : 24 : Py_DECREF(check_id);
1321 [ - + ]: 24 : if (in_seen == -1) {
1322 : 0 : PyErr_Clear();
1323 : 0 : return true;
1324 : : }
1325 : :
1326 [ + + ]: 24 : if (in_seen == 1) {
1327 : : /* value is in seen */
1328 : 2 : return true;
1329 : : }
1330 : 22 : return false;
1331 : : }
1332 : :
1333 : : static int
1334 : 409 : print_exception_cause_and_context(struct exception_print_context *ctx,
1335 : : PyObject *value)
1336 : : {
1337 : 409 : PyObject *value_id = PyLong_FromVoidPtr(value);
1338 [ + - - + ]: 409 : if (value_id == NULL || PySet_Add(ctx->seen, value_id) == -1) {
1339 : 0 : PyErr_Clear();
1340 : 0 : Py_XDECREF(value_id);
1341 : 0 : return 0;
1342 : : }
1343 : 409 : Py_DECREF(value_id);
1344 : :
1345 [ + + ]: 409 : if (!PyExceptionInstance_Check(value)) {
1346 : 2 : return 0;
1347 : : }
1348 : :
1349 : 407 : PyObject *cause = PyException_GetCause(value);
1350 [ + + ]: 407 : if (cause) {
1351 : 13 : int err = 0;
1352 [ + + ]: 13 : if (!print_exception_seen_lookup(ctx, cause)) {
1353 : 11 : err = print_chained(ctx, cause, cause_message, "cause");
1354 : : }
1355 : 13 : Py_DECREF(cause);
1356 : 13 : return err;
1357 : : }
1358 [ + + ]: 394 : if (((PyBaseExceptionObject *)value)->suppress_context) {
1359 : 2 : return 0;
1360 : : }
1361 : 392 : PyObject *context = PyException_GetContext(value);
1362 [ + + ]: 392 : if (context) {
1363 : 11 : int err = 0;
1364 [ + - ]: 11 : if (!print_exception_seen_lookup(ctx, context)) {
1365 : 11 : err = print_chained(ctx, context, context_message, "context");
1366 : : }
1367 : 11 : Py_DECREF(context);
1368 : 11 : return err;
1369 : : }
1370 : 381 : return 0;
1371 : : }
1372 : :
1373 : : static int
1374 : 34 : print_exception_group(struct exception_print_context *ctx, PyObject *value)
1375 : : {
1376 : 34 : PyObject *f = ctx->file;
1377 : :
1378 [ + + ]: 34 : if (ctx->exception_group_depth > ctx->max_group_depth) {
1379 : : /* depth exceeds limit */
1380 : :
1381 [ - + ]: 2 : if (write_indented_margin(ctx, f) < 0) {
1382 : 0 : return -1;
1383 : : }
1384 : :
1385 : 2 : PyObject *line = PyUnicode_FromFormat("... (max_group_depth is %d)\n",
1386 : : ctx->max_group_depth);
1387 [ - + ]: 2 : if (line == NULL) {
1388 : 0 : return -1;
1389 : : }
1390 : 2 : int err = PyFile_WriteObject(line, f, Py_PRINT_RAW);
1391 : 2 : Py_DECREF(line);
1392 : 2 : return err;
1393 : : }
1394 : :
1395 [ + + ]: 32 : if (ctx->exception_group_depth == 0) {
1396 : 13 : ctx->exception_group_depth += 1;
1397 : : }
1398 : 32 : print_exception(ctx, value);
1399 : :
1400 : 32 : PyObject *excs = ((PyBaseExceptionGroupObject *)value)->excs;
1401 : : assert(excs && PyTuple_Check(excs));
1402 : 32 : Py_ssize_t num_excs = PyTuple_GET_SIZE(excs);
1403 : : assert(num_excs > 0);
1404 : : Py_ssize_t n;
1405 [ + + ]: 32 : if (num_excs <= ctx->max_group_width) {
1406 : 31 : n = num_excs;
1407 : : }
1408 : : else {
1409 : 1 : n = ctx->max_group_width + 1;
1410 : : }
1411 : :
1412 : 32 : ctx->need_close = false;
1413 [ + + ]: 110 : for (Py_ssize_t i = 0; i < n; i++) {
1414 : 78 : bool last_exc = (i == n - 1);
1415 [ + + ]: 78 : if (last_exc) {
1416 : : // The closing frame may be added in a recursive call
1417 : 32 : ctx->need_close = true;
1418 : : }
1419 : :
1420 [ - + ]: 78 : if (_Py_WriteIndent(EXC_INDENT(ctx), f) < 0) {
1421 : 0 : return -1;
1422 : : }
1423 : 78 : bool truncated = (i >= ctx->max_group_width);
1424 : : PyObject *line;
1425 [ + + ]: 78 : if (!truncated) {
1426 [ + + ]: 77 : line = PyUnicode_FromFormat(
1427 : : "%s+---------------- %zd ----------------\n",
1428 : : (i == 0) ? "+-" : " ", i + 1);
1429 : : }
1430 : : else {
1431 [ - + ]: 1 : line = PyUnicode_FromFormat(
1432 : : "%s+---------------- ... ----------------\n",
1433 : : (i == 0) ? "+-" : " ");
1434 : : }
1435 [ - + ]: 78 : if (line == NULL) {
1436 : 0 : return -1;
1437 : : }
1438 : 78 : int err = PyFile_WriteObject(line, f, Py_PRINT_RAW);
1439 : 78 : Py_DECREF(line);
1440 [ - + ]: 78 : if (err < 0) {
1441 : 0 : return -1;
1442 : : }
1443 : :
1444 : 78 : ctx->exception_group_depth += 1;
1445 : 78 : PyObject *exc = PyTuple_GET_ITEM(excs, i);
1446 : :
1447 [ + + ]: 78 : if (!truncated) {
1448 [ - + ]: 77 : if (_Py_EnterRecursiveCall(" in print_exception_group") != 0) {
1449 : 0 : return -1;
1450 : : }
1451 : 77 : int res = print_exception_recursive(ctx, exc);
1452 : 77 : _Py_LeaveRecursiveCall();
1453 [ - + ]: 77 : if (res < 0) {
1454 : 0 : return -1;
1455 : : }
1456 : : }
1457 : : else {
1458 : 1 : Py_ssize_t excs_remaining = num_excs - ctx->max_group_width;
1459 : :
1460 [ - + ]: 1 : if (write_indented_margin(ctx, f) < 0) {
1461 : 0 : return -1;
1462 : : }
1463 : :
1464 [ + - ]: 1 : PyObject *line = PyUnicode_FromFormat(
1465 : : "and %zd more exception%s\n",
1466 : : excs_remaining, excs_remaining > 1 ? "s" : "");
1467 : :
1468 [ - + ]: 1 : if (line == NULL) {
1469 : 0 : return -1;
1470 : : }
1471 : :
1472 : 1 : int err = PyFile_WriteObject(line, f, Py_PRINT_RAW);
1473 : 1 : Py_DECREF(line);
1474 [ - + ]: 1 : if (err < 0) {
1475 : 0 : return -1;
1476 : : }
1477 : : }
1478 : :
1479 [ + + + + ]: 78 : if (last_exc && ctx->need_close) {
1480 [ - + ]: 23 : if (_Py_WriteIndent(EXC_INDENT(ctx), f) < 0) {
1481 : 0 : return -1;
1482 : : }
1483 [ - + ]: 23 : if (PyFile_WriteString(
1484 : : "+------------------------------------\n", f) < 0) {
1485 : 0 : return -1;
1486 : : }
1487 : 23 : ctx->need_close = false;
1488 : : }
1489 : 78 : ctx->exception_group_depth -= 1;
1490 : : }
1491 : :
1492 [ + + ]: 32 : if (ctx->exception_group_depth == 1) {
1493 : 13 : ctx->exception_group_depth -= 1;
1494 : : }
1495 : 32 : return 0;
1496 : : }
1497 : :
1498 : : static int
1499 : 443 : print_exception_recursive(struct exception_print_context *ctx, PyObject *value)
1500 : : {
1501 [ + + ]: 443 : if (ctx->seen != NULL) {
1502 : : /* Exception chaining */
1503 [ - + ]: 409 : if (print_exception_cause_and_context(ctx, value) < 0) {
1504 : 0 : return -1;
1505 : : }
1506 : : }
1507 [ + + ]: 443 : if (!_PyBaseExceptionGroup_Check(value)) {
1508 [ + + ]: 409 : if (print_exception(ctx, value) < 0) {
1509 : 33 : return -1;
1510 : : }
1511 : : }
1512 [ - + ]: 34 : else if (print_exception_group(ctx, value) < 0) {
1513 : 0 : return -1;
1514 : : }
1515 : : assert(!PyErr_Occurred());
1516 : 410 : return 0;
1517 : : }
1518 : :
1519 : : #define PyErr_MAX_GROUP_WIDTH 15
1520 : : #define PyErr_MAX_GROUP_DEPTH 10
1521 : :
1522 : : void
1523 : 344 : _PyErr_Display(PyObject *file, PyObject *exception, PyObject *value, PyObject *tb)
1524 : : {
1525 : : assert(file != NULL && file != Py_None);
1526 [ + + ]: 344 : if (PyExceptionInstance_Check(value)
1527 [ + + + + ]: 342 : && tb != NULL && PyTraceBack_Check(tb)) {
1528 : : /* Put the traceback on the exception, otherwise it won't get
1529 : : displayed. See issue #18776. */
1530 : 223 : PyObject *cur_tb = PyException_GetTraceback(value);
1531 [ - + ]: 223 : if (cur_tb == NULL)
1532 : 0 : PyException_SetTraceback(value, tb);
1533 : : else
1534 : 223 : Py_DECREF(cur_tb);
1535 : : }
1536 : :
1537 : : struct exception_print_context ctx;
1538 : 344 : ctx.file = file;
1539 : 344 : ctx.exception_group_depth = 0;
1540 : 344 : ctx.need_close = false;
1541 : 344 : ctx.max_group_width = PyErr_MAX_GROUP_WIDTH;
1542 : 344 : ctx.max_group_depth = PyErr_MAX_GROUP_DEPTH;
1543 : :
1544 : : /* We choose to ignore seen being possibly NULL, and report
1545 : : at least the main exception (it could be a MemoryError).
1546 : : */
1547 : 344 : ctx.seen = PySet_New(NULL);
1548 [ + + ]: 344 : if (ctx.seen == NULL) {
1549 : 34 : PyErr_Clear();
1550 : : }
1551 [ + + ]: 344 : if (print_exception_recursive(&ctx, value) < 0) {
1552 : 33 : PyErr_Clear();
1553 : 33 : _PyObject_Dump(value);
1554 : 33 : fprintf(stderr, "lost sys.stderr\n");
1555 : : }
1556 : 344 : Py_XDECREF(ctx.seen);
1557 : :
1558 : : /* Call file.flush() */
1559 : 344 : PyObject *res = _PyObject_CallMethodNoArgs(file, &_Py_ID(flush));
1560 [ + + ]: 344 : if (!res) {
1561 : : /* Silently ignore file.flush() error */
1562 : 1 : PyErr_Clear();
1563 : : }
1564 : : else {
1565 : 343 : Py_DECREF(res);
1566 : : }
1567 : 344 : }
1568 : :
1569 : : void
1570 : 337 : PyErr_Display(PyObject *exception, PyObject *value, PyObject *tb)
1571 : : {
1572 : 337 : PyThreadState *tstate = _PyThreadState_GET();
1573 : 337 : PyObject *file = _PySys_GetAttr(tstate, &_Py_ID(stderr));
1574 [ - + ]: 337 : if (file == NULL) {
1575 : 0 : _PyObject_Dump(value);
1576 : 0 : fprintf(stderr, "lost sys.stderr\n");
1577 : 0 : return;
1578 : : }
1579 [ - + ]: 337 : if (file == Py_None) {
1580 : 0 : return;
1581 : : }
1582 : 337 : Py_INCREF(file);
1583 : 337 : _PyErr_Display(file, exception, value, tb);
1584 : 337 : Py_DECREF(file);
1585 : : }
1586 : :
1587 : : PyObject *
1588 : 95782 : PyRun_StringFlags(const char *str, int start, PyObject *globals,
1589 : : PyObject *locals, PyCompilerFlags *flags)
1590 : : {
1591 : 95782 : PyObject *ret = NULL;
1592 : : mod_ty mod;
1593 : : PyArena *arena;
1594 : :
1595 : 95782 : arena = _PyArena_New();
1596 [ - + ]: 95782 : if (arena == NULL)
1597 : 0 : return NULL;
1598 : :
1599 : : _Py_DECLARE_STR(anon_string, "<string>");
1600 : 95782 : mod = _PyParser_ASTFromString(
1601 : : str, &_Py_STR(anon_string), start, flags, arena);
1602 : :
1603 [ + + ]: 95782 : if (mod != NULL)
1604 : 95269 : ret = run_mod(mod, &_Py_STR(anon_string), globals, locals, flags, arena);
1605 : 95780 : _PyArena_Free(arena);
1606 : 95780 : return ret;
1607 : : }
1608 : :
1609 : :
1610 : : static PyObject *
1611 : 328 : pyrun_file(FILE *fp, PyObject *filename, int start, PyObject *globals,
1612 : : PyObject *locals, int closeit, PyCompilerFlags *flags)
1613 : : {
1614 : 328 : PyArena *arena = _PyArena_New();
1615 [ - + ]: 328 : if (arena == NULL) {
1616 : 0 : return NULL;
1617 : : }
1618 : :
1619 : : mod_ty mod;
1620 : 328 : mod = _PyParser_ASTFromFile(fp, filename, NULL, start, NULL, NULL,
1621 : : flags, NULL, arena);
1622 : :
1623 [ + + ]: 328 : if (closeit) {
1624 : 310 : fclose(fp);
1625 : : }
1626 : :
1627 : : PyObject *ret;
1628 [ + + ]: 328 : if (mod != NULL) {
1629 : 312 : ret = run_mod(mod, filename, globals, locals, flags, arena);
1630 : : }
1631 : : else {
1632 : 16 : ret = NULL;
1633 : : }
1634 : 328 : _PyArena_Free(arena);
1635 : :
1636 : 328 : return ret;
1637 : : }
1638 : :
1639 : :
1640 : : PyObject *
1641 : 0 : PyRun_FileExFlags(FILE *fp, const char *filename, int start, PyObject *globals,
1642 : : PyObject *locals, int closeit, PyCompilerFlags *flags)
1643 : : {
1644 : 0 : PyObject *filename_obj = PyUnicode_DecodeFSDefault(filename);
1645 [ # # ]: 0 : if (filename_obj == NULL) {
1646 : 0 : return NULL;
1647 : : }
1648 : :
1649 : 0 : PyObject *res = pyrun_file(fp, filename_obj, start, globals,
1650 : : locals, closeit, flags);
1651 : 0 : Py_DECREF(filename_obj);
1652 : 0 : return res;
1653 : :
1654 : : }
1655 : :
1656 : :
1657 : : static void
1658 : 391 : flush_io(void)
1659 : : {
1660 : : PyObject *f, *r;
1661 : : PyObject *type, *value, *traceback;
1662 : :
1663 : : /* Save the current exception */
1664 : 391 : PyErr_Fetch(&type, &value, &traceback);
1665 : :
1666 : 391 : PyThreadState *tstate = _PyThreadState_GET();
1667 : 391 : f = _PySys_GetAttr(tstate, &_Py_ID(stderr));
1668 [ + - ]: 391 : if (f != NULL) {
1669 : 391 : r = _PyObject_CallMethodNoArgs(f, &_Py_ID(flush));
1670 [ + - ]: 391 : if (r)
1671 : 391 : Py_DECREF(r);
1672 : : else
1673 : 0 : PyErr_Clear();
1674 : : }
1675 : 391 : f = _PySys_GetAttr(tstate, &_Py_ID(stdout));
1676 [ + - ]: 391 : if (f != NULL) {
1677 : 391 : r = _PyObject_CallMethodNoArgs(f, &_Py_ID(flush));
1678 [ + - ]: 391 : if (r)
1679 : 391 : Py_DECREF(r);
1680 : : else
1681 : 0 : PyErr_Clear();
1682 : : }
1683 : :
1684 : 391 : PyErr_Restore(type, value, traceback);
1685 : 391 : }
1686 : :
1687 : : static PyObject *
1688 : 95527 : run_eval_code_obj(PyThreadState *tstate, PyCodeObject *co, PyObject *globals, PyObject *locals)
1689 : : {
1690 : : PyObject *v;
1691 : : /*
1692 : : * We explicitly re-initialize _Py_UnhandledKeyboardInterrupt every eval
1693 : : * _just in case_ someone is calling into an embedded Python where they
1694 : : * don't care about an uncaught KeyboardInterrupt exception (why didn't they
1695 : : * leave config.install_signal_handlers set to 0?!?) but then later call
1696 : : * Py_Main() itself (which _checks_ this flag and dies with a signal after
1697 : : * its interpreter exits). We don't want a previous embedded interpreter's
1698 : : * uncaught exception to trigger an unexplained signal exit from a future
1699 : : * Py_Main() based one.
1700 : : */
1701 : 95527 : _Py_UnhandledKeyboardInterrupt = 0;
1702 : :
1703 : : /* Set globals['__builtins__'] if it doesn't exist */
1704 [ + - + + ]: 95527 : if (globals != NULL && _PyDict_GetItemStringWithError(globals, "__builtins__") == NULL) {
1705 [ + - - + ]: 2 : if (PyErr_Occurred() ||
1706 : 1 : PyDict_SetItemString(globals, "__builtins__",
1707 : 1 : tstate->interp->builtins) < 0)
1708 : : {
1709 : 0 : return NULL;
1710 : : }
1711 : : }
1712 : :
1713 : 95527 : v = PyEval_EvalCode((PyObject*)co, globals, locals);
1714 [ + + - + ]: 95525 : if (!v && _PyErr_Occurred(tstate) == PyExc_KeyboardInterrupt) {
1715 : 0 : _Py_UnhandledKeyboardInterrupt = 1;
1716 : : }
1717 : 95525 : return v;
1718 : : }
1719 : :
1720 : : static PyObject *
1721 : 95603 : run_mod(mod_ty mod, PyObject *filename, PyObject *globals, PyObject *locals,
1722 : : PyCompilerFlags *flags, PyArena *arena)
1723 : : {
1724 : 95603 : PyThreadState *tstate = _PyThreadState_GET();
1725 : 95603 : PyCodeObject *co = _PyAST_Compile(mod, filename, flags, -1, arena);
1726 [ + + ]: 95603 : if (co == NULL)
1727 : 104 : return NULL;
1728 : :
1729 [ - + ]: 95499 : if (_PySys_Audit(tstate, "exec", "O", co) < 0) {
1730 : 0 : Py_DECREF(co);
1731 : 0 : return NULL;
1732 : : }
1733 : :
1734 : 95499 : PyObject *v = run_eval_code_obj(tstate, co, globals, locals);
1735 : 95497 : Py_DECREF(co);
1736 : 95497 : return v;
1737 : : }
1738 : :
1739 : : static PyObject *
1740 : 28 : run_pyc_file(FILE *fp, PyObject *globals, PyObject *locals,
1741 : : PyCompilerFlags *flags)
1742 : : {
1743 : 28 : PyThreadState *tstate = _PyThreadState_GET();
1744 : : PyCodeObject *co;
1745 : : PyObject *v;
1746 : : long magic;
1747 : : long PyImport_GetMagicNumber(void);
1748 : :
1749 : 28 : magic = PyMarshal_ReadLongFromFile(fp);
1750 [ - + ]: 28 : if (magic != PyImport_GetMagicNumber()) {
1751 [ # # ]: 0 : if (!PyErr_Occurred())
1752 : 0 : PyErr_SetString(PyExc_RuntimeError,
1753 : : "Bad magic number in .pyc file");
1754 : 0 : goto error;
1755 : : }
1756 : : /* Skip the rest of the header. */
1757 : 28 : (void) PyMarshal_ReadLongFromFile(fp);
1758 : 28 : (void) PyMarshal_ReadLongFromFile(fp);
1759 : 28 : (void) PyMarshal_ReadLongFromFile(fp);
1760 [ - + ]: 28 : if (PyErr_Occurred()) {
1761 : 0 : goto error;
1762 : : }
1763 : 28 : v = PyMarshal_ReadLastObjectFromFile(fp);
1764 [ + - - + ]: 28 : if (v == NULL || !PyCode_Check(v)) {
1765 : 0 : Py_XDECREF(v);
1766 : 0 : PyErr_SetString(PyExc_RuntimeError,
1767 : : "Bad code object in .pyc file");
1768 : 0 : goto error;
1769 : : }
1770 : 28 : fclose(fp);
1771 : 28 : co = (PyCodeObject *)v;
1772 : 28 : v = run_eval_code_obj(tstate, co, globals, locals);
1773 [ + + + - ]: 28 : if (v && flags)
1774 : 4 : flags->cf_flags |= (co->co_flags & PyCF_MASK);
1775 : 28 : Py_DECREF(co);
1776 : 28 : return v;
1777 : 0 : error:
1778 : 0 : fclose(fp);
1779 : 0 : return NULL;
1780 : : }
1781 : :
1782 : : PyObject *
1783 : 29610 : Py_CompileStringObject(const char *str, PyObject *filename, int start,
1784 : : PyCompilerFlags *flags, int optimize)
1785 : : {
1786 : : PyCodeObject *co;
1787 : : mod_ty mod;
1788 : 29610 : PyArena *arena = _PyArena_New();
1789 [ - + ]: 29610 : if (arena == NULL)
1790 : 0 : return NULL;
1791 : :
1792 : 29610 : mod = _PyParser_ASTFromString(str, filename, start, flags, arena);
1793 [ + + ]: 29610 : if (mod == NULL) {
1794 : 1698 : _PyArena_Free(arena);
1795 : 1698 : return NULL;
1796 : : }
1797 [ + + + + ]: 27912 : if (flags && (flags->cf_flags & PyCF_ONLY_AST)) {
1798 : 10350 : PyObject *result = PyAST_mod2obj(mod);
1799 : 10350 : _PyArena_Free(arena);
1800 : 10350 : return result;
1801 : : }
1802 : 17562 : co = _PyAST_Compile(mod, filename, flags, optimize, arena);
1803 : 17562 : _PyArena_Free(arena);
1804 : 17562 : return (PyObject *)co;
1805 : : }
1806 : :
1807 : : PyObject *
1808 : 5 : Py_CompileStringExFlags(const char *str, const char *filename_str, int start,
1809 : : PyCompilerFlags *flags, int optimize)
1810 : : {
1811 : : PyObject *filename, *co;
1812 : 5 : filename = PyUnicode_DecodeFSDefault(filename_str);
1813 [ - + ]: 5 : if (filename == NULL)
1814 : 0 : return NULL;
1815 : 5 : co = Py_CompileStringObject(str, filename, start, flags, optimize);
1816 : 5 : Py_DECREF(filename);
1817 : 5 : return co;
1818 : : }
1819 : :
1820 : : const char *
1821 : 123608 : _Py_SourceAsString(PyObject *cmd, const char *funcname, const char *what, PyCompilerFlags *cf, PyObject **cmd_copy)
1822 : : {
1823 : : const char *str;
1824 : : Py_ssize_t size;
1825 : : Py_buffer view;
1826 : :
1827 : 123608 : *cmd_copy = NULL;
1828 [ + + ]: 123608 : if (PyUnicode_Check(cmd)) {
1829 : 111837 : cf->cf_flags |= PyCF_IGNORE_COOKIE;
1830 : 111837 : str = PyUnicode_AsUTF8AndSize(cmd, &size);
1831 [ - + ]: 111837 : if (str == NULL)
1832 : 0 : return NULL;
1833 : : }
1834 [ + + ]: 11771 : else if (PyBytes_Check(cmd)) {
1835 : 11761 : str = PyBytes_AS_STRING(cmd);
1836 : 11761 : size = PyBytes_GET_SIZE(cmd);
1837 : : }
1838 [ - + ]: 10 : else if (PyByteArray_Check(cmd)) {
1839 : 0 : str = PyByteArray_AS_STRING(cmd);
1840 : 0 : size = PyByteArray_GET_SIZE(cmd);
1841 : : }
1842 [ + + ]: 10 : else if (PyObject_GetBuffer(cmd, &view, PyBUF_SIMPLE) == 0) {
1843 : : /* Copy to NUL-terminated buffer. */
1844 : 14 : *cmd_copy = PyBytes_FromStringAndSize(
1845 : 7 : (const char *)view.buf, view.len);
1846 : 7 : PyBuffer_Release(&view);
1847 [ - + ]: 7 : if (*cmd_copy == NULL) {
1848 : 0 : return NULL;
1849 : : }
1850 : 7 : str = PyBytes_AS_STRING(*cmd_copy);
1851 : 7 : size = PyBytes_GET_SIZE(*cmd_copy);
1852 : : }
1853 : : else {
1854 : 3 : PyErr_Format(PyExc_TypeError,
1855 : : "%s() arg 1 must be a %s object",
1856 : : funcname, what);
1857 : 3 : return NULL;
1858 : : }
1859 : :
1860 [ + + ]: 123605 : if (strlen(str) != (size_t)size) {
1861 : 4 : PyErr_SetString(PyExc_ValueError,
1862 : : "source code string cannot contain null bytes");
1863 [ + + ]: 4 : Py_CLEAR(*cmd_copy);
1864 : 4 : return NULL;
1865 : : }
1866 : 123601 : return str;
1867 : : }
1868 : :
1869 : : #if defined(USE_STACKCHECK)
1870 : : #if defined(WIN32) && defined(_MSC_VER)
1871 : :
1872 : : /* Stack checking for Microsoft C */
1873 : :
1874 : : #include <malloc.h>
1875 : : #include <excpt.h>
1876 : :
1877 : : /*
1878 : : * Return non-zero when we run out of memory on the stack; zero otherwise.
1879 : : */
1880 : : int
1881 : : PyOS_CheckStack(void)
1882 : : {
1883 : : __try {
1884 : : /* alloca throws a stack overflow exception if there's
1885 : : not enough space left on the stack */
1886 : : alloca(PYOS_STACK_MARGIN * sizeof(void*));
1887 : : return 0;
1888 : : } __except (GetExceptionCode() == STATUS_STACK_OVERFLOW ?
1889 : : EXCEPTION_EXECUTE_HANDLER :
1890 : : EXCEPTION_CONTINUE_SEARCH) {
1891 : : int errcode = _resetstkoflw();
1892 : : if (errcode == 0)
1893 : : {
1894 : : Py_FatalError("Could not reset the stack!");
1895 : : }
1896 : : }
1897 : : return 1;
1898 : : }
1899 : :
1900 : : #endif /* WIN32 && _MSC_VER */
1901 : :
1902 : : /* Alternate implementations can be added here... */
1903 : :
1904 : : #endif /* USE_STACKCHECK */
1905 : :
1906 : : /* Deprecated C API functions still provided for binary compatibility */
1907 : :
1908 : : #undef PyRun_AnyFile
1909 : : PyAPI_FUNC(int)
1910 : 0 : PyRun_AnyFile(FILE *fp, const char *name)
1911 : : {
1912 : 0 : return PyRun_AnyFileExFlags(fp, name, 0, NULL);
1913 : : }
1914 : :
1915 : : #undef PyRun_AnyFileEx
1916 : : PyAPI_FUNC(int)
1917 : 0 : PyRun_AnyFileEx(FILE *fp, const char *name, int closeit)
1918 : : {
1919 : 0 : return PyRun_AnyFileExFlags(fp, name, closeit, NULL);
1920 : : }
1921 : :
1922 : : #undef PyRun_AnyFileFlags
1923 : : PyAPI_FUNC(int)
1924 : 0 : PyRun_AnyFileFlags(FILE *fp, const char *name, PyCompilerFlags *flags)
1925 : : {
1926 : 0 : return PyRun_AnyFileExFlags(fp, name, 0, flags);
1927 : : }
1928 : :
1929 : : #undef PyRun_File
1930 : : PyAPI_FUNC(PyObject *)
1931 : 0 : PyRun_File(FILE *fp, const char *p, int s, PyObject *g, PyObject *l)
1932 : : {
1933 : 0 : return PyRun_FileExFlags(fp, p, s, g, l, 0, NULL);
1934 : : }
1935 : :
1936 : : #undef PyRun_FileEx
1937 : : PyAPI_FUNC(PyObject *)
1938 : 0 : PyRun_FileEx(FILE *fp, const char *p, int s, PyObject *g, PyObject *l, int c)
1939 : : {
1940 : 0 : return PyRun_FileExFlags(fp, p, s, g, l, c, NULL);
1941 : : }
1942 : :
1943 : : #undef PyRun_FileFlags
1944 : : PyAPI_FUNC(PyObject *)
1945 : 0 : PyRun_FileFlags(FILE *fp, const char *p, int s, PyObject *g, PyObject *l,
1946 : : PyCompilerFlags *flags)
1947 : : {
1948 : 0 : return PyRun_FileExFlags(fp, p, s, g, l, 0, flags);
1949 : : }
1950 : :
1951 : : #undef PyRun_SimpleFile
1952 : : PyAPI_FUNC(int)
1953 : 0 : PyRun_SimpleFile(FILE *f, const char *p)
1954 : : {
1955 : 0 : return PyRun_SimpleFileExFlags(f, p, 0, NULL);
1956 : : }
1957 : :
1958 : : #undef PyRun_SimpleFileEx
1959 : : PyAPI_FUNC(int)
1960 : 0 : PyRun_SimpleFileEx(FILE *f, const char *p, int c)
1961 : : {
1962 : 0 : return PyRun_SimpleFileExFlags(f, p, c, NULL);
1963 : : }
1964 : :
1965 : :
1966 : : #undef PyRun_String
1967 : : PyAPI_FUNC(PyObject *)
1968 : 0 : PyRun_String(const char *str, int s, PyObject *g, PyObject *l)
1969 : : {
1970 : 0 : return PyRun_StringFlags(str, s, g, l, NULL);
1971 : : }
1972 : :
1973 : : #undef PyRun_SimpleString
1974 : : PyAPI_FUNC(int)
1975 : 0 : PyRun_SimpleString(const char *s)
1976 : : {
1977 : 0 : return PyRun_SimpleStringFlags(s, NULL);
1978 : : }
1979 : :
1980 : : #undef Py_CompileString
1981 : : PyAPI_FUNC(PyObject *)
1982 : 0 : Py_CompileString(const char *str, const char *p, int s)
1983 : : {
1984 : 0 : return Py_CompileStringExFlags(str, p, s, NULL, -1);
1985 : : }
1986 : :
1987 : : #undef Py_CompileStringFlags
1988 : : PyAPI_FUNC(PyObject *)
1989 : 0 : Py_CompileStringFlags(const char *str, const char *p, int s,
1990 : : PyCompilerFlags *flags)
1991 : : {
1992 : 0 : return Py_CompileStringExFlags(str, p, s, flags, -1);
1993 : : }
1994 : :
1995 : : #undef PyRun_InteractiveOne
1996 : : PyAPI_FUNC(int)
1997 : 0 : PyRun_InteractiveOne(FILE *f, const char *p)
1998 : : {
1999 : 0 : return PyRun_InteractiveOneFlags(f, p, NULL);
2000 : : }
2001 : :
2002 : : #undef PyRun_InteractiveLoop
2003 : : PyAPI_FUNC(int)
2004 : 0 : PyRun_InteractiveLoop(FILE *f, const char *p)
2005 : : {
2006 : 0 : return PyRun_InteractiveLoopFlags(f, p, NULL);
2007 : : }
2008 : :
2009 : : #ifdef __cplusplus
2010 : : }
2011 : : #endif
|
