LCOV - code coverage report
Current view: top level - Python - pythonrun.c (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 160 1004 15.9 %
Date: 2023-03-20 08:15:36 Functions: 15 62 24.2 %
Branches: 58 588 9.9 %

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

Generated by: LCOV version 1.14