pythonrun.c

/* Top level execution of Python code (including in __main__) */

/* To help control the interfaces between the startup, execution and
 * shutdown code, the phases are split across separate modules (bootstrap,
 * pythonrun, shutdown)
 */

/* TODO: Cull includes following phase split */

#include"Python.h"

#include"pycore_ast.h"// PyAST_mod2obj()
#include"pycore_ceval.h"// _Py_EnterRecursiveCall()
#include"pycore_compile.h"// _PyAST_Compile()
#include"pycore_interp.h"// PyInterpreterState.importlib
#include"pycore_object.h"// _PyDebug_PrintTotalRefs()
#include"pycore_parser.h"// _PyParser_ASTFromString()
#include"pycore_pyerrors.h"// _PyErr_GetRaisedException()
#include"pycore_pylifecycle.h"// _Py_FdIsInteractive()
#include"pycore_pystate.h"// _PyInterpreterState_GET()
#include"pycore_pythonrun.h"// export _PyRun_InteractiveLoopObject()
#include"pycore_sysmodule.h"// _PySys_Audit()
#include"pycore_traceback.h"// _PyTraceBack_Print()

#include"errcode.h"// E_EOF
#include"marshal.h"// PyMarshal_ReadLongFromFile()

#include<stdbool.h>

#ifdefMS_WINDOWS
# include"malloc.h"// alloca()
#endif

#ifdefMS_WINDOWS
# undef BYTE
# include"windows.h"
#endif

/* Forward */
staticvoidflush_io(void);
staticPyObject*run_mod(mod_ty, PyObject*, PyObject*, PyObject*,
PyCompilerFlags*, PyArena*, PyObject*, int);
staticPyObject*run_pyc_file(FILE*, PyObject*, PyObject*,
PyCompilerFlags*);
staticintPyRun_InteractiveOneObjectEx(FILE*, PyObject*, PyCompilerFlags*);
staticPyObject*pyrun_file(FILE*fp, PyObject*filename, intstart,
PyObject*globals, PyObject*locals, intcloseit,
PyCompilerFlags*flags);
staticPyObject*
_PyRun_StringFlagsWithName(constchar*str, PyObject*name, intstart,
PyObject*globals, PyObject*locals, PyCompilerFlags*flags,
intgenerate_new_source);

int
_PyRun_AnyFileObject(FILE*fp, PyObject*filename, intcloseit,
PyCompilerFlags*flags)
{
intdecref_filename=0;
if (filename==NULL) {
filename=PyUnicode_FromString("???");
if (filename==NULL) {
PyErr_Print();
return-1;
 }
decref_filename=1;
 }

intres;
if (_Py_FdIsInteractive(fp, filename)) {
res=_PyRun_InteractiveLoopObject(fp, filename, flags);
if (closeit) {
fclose(fp);
 }
 }
else {
res=_PyRun_SimpleFileObject(fp, filename, closeit, flags);
 }

if (decref_filename) {
Py_DECREF(filename);
 }
returnres;
}

int
PyRun_AnyFileExFlags(FILE*fp, constchar*filename, intcloseit,
PyCompilerFlags*flags)
{
PyObject*filename_obj=NULL;
if (filename!=NULL) {
filename_obj=PyUnicode_DecodeFSDefault(filename);
if (filename_obj==NULL) {
PyErr_Print();
return-1;
 }
 }
intres=_PyRun_AnyFileObject(fp, filename_obj, closeit, flags);
Py_XDECREF(filename_obj);
returnres;
}


int
_PyRun_InteractiveLoopObject(FILE*fp, PyObject*filename, PyCompilerFlags*flags)
{
PyCompilerFlagslocal_flags=_PyCompilerFlags_INIT;
if (flags==NULL) {
flags=&local_flags;
 }

PyObject*v;
if (_PySys_GetOptionalAttr(&_Py_ID(ps1), &v) <0) {
PyErr_Print();
return-1;
 }
if (v==NULL) {
v=PyUnicode_FromString(">>> ");
if (v==NULL) {
PyErr_Clear();
 }
if (_PySys_SetAttr(&_Py_ID(ps1), v) <0) {
PyErr_Clear();
 }
 }
Py_XDECREF(v);
if (_PySys_GetOptionalAttr(&_Py_ID(ps2), &v) <0) {
PyErr_Print();
return-1;
 }
if (v==NULL) {
v=PyUnicode_FromString("... ");
if (v==NULL) {
PyErr_Clear();
 }
if (_PySys_SetAttr(&_Py_ID(ps2), v) <0) {
PyErr_Clear();
 }
 }
Py_XDECREF(v);

#ifdefPy_REF_DEBUG
intshow_ref_count=_Py_GetConfig()->show_ref_count;
#endif
interr=0;
intret;
intnomem_count=0;
do {
ret=PyRun_InteractiveOneObjectEx(fp, filename, flags);
if (ret==-1&&PyErr_Occurred()) {
/* Prevent an endless loop after multiple consecutive MemoryErrors
 * while still allowing an interactive command to fail with a
 * MemoryError. */
if (PyErr_ExceptionMatches(PyExc_MemoryError)) {
if (++nomem_count>16) {
PyErr_Clear();
err=-1;
break;
 }
 } else {
nomem_count=0;
 }
PyErr_Print();
flush_io();
 } else {
nomem_count=0;
 }
#ifdefPy_REF_DEBUG
if (show_ref_count) {
_PyDebug_PrintTotalRefs();
 }
#endif
 } while (ret!=E_EOF);
returnerr;
}


int
PyRun_InteractiveLoopFlags(FILE*fp, constchar*filename, PyCompilerFlags*flags)
{
PyObject*filename_obj=PyUnicode_DecodeFSDefault(filename);
if (filename_obj==NULL) {
PyErr_Print();
return-1;
 }

interr=_PyRun_InteractiveLoopObject(fp, filename_obj, flags);
Py_DECREF(filename_obj);
returnerr;

}


// Call _PyParser_ASTFromFile() with sys.stdin.encoding, sys.ps1 and sys.ps2
staticint
pyrun_one_parse_ast(FILE*fp, PyObject*filename,
PyCompilerFlags*flags, PyArena*arena,
mod_ty*pmod, PyObject**interactive_src)
{
// Get sys.stdin.encoding (as UTF-8)
PyObject*attr;
PyObject*encoding_obj=NULL;
constchar*encoding=NULL;
if (fp==stdin) {
if (_PySys_GetOptionalAttr(&_Py_ID(stdin), &attr) <0) {
PyErr_Clear();
 }
elseif (attr!=NULL&&attr!=Py_None) {
if (PyObject_GetOptionalAttr(attr, &_Py_ID(encoding), &encoding_obj) <0) {
PyErr_Clear();
 }
elseif (encoding_obj&&PyUnicode_Check(encoding_obj)) {
encoding=PyUnicode_AsUTF8(encoding_obj);
if (!encoding) {
PyErr_Clear();
 }
 }
 }
Py_XDECREF(attr);
 }

// Get sys.ps1 (as UTF-8)
PyObject*ps1_obj=NULL;
constchar*ps1="";
if (_PySys_GetOptionalAttr(&_Py_ID(ps1), &attr) <0) {
PyErr_Clear();
 }
elseif (attr!=NULL) {
ps1_obj=PyObject_Str(attr);
Py_DECREF(attr);
if (ps1_obj==NULL) {
PyErr_Clear();
 }
elseif (PyUnicode_Check(ps1_obj)) {
ps1=PyUnicode_AsUTF8(ps1_obj);
if (ps1==NULL) {
PyErr_Clear();
ps1="";
 }
 }
 }

// Get sys.ps2 (as UTF-8)
PyObject*ps2_obj=NULL;
constchar*ps2="";
if (_PySys_GetOptionalAttr(&_Py_ID(ps2), &attr) <0) {
PyErr_Clear();
 }
elseif (attr!=NULL) {
ps2_obj=PyObject_Str(attr);
Py_DECREF(attr);
if (ps2_obj==NULL) {
PyErr_Clear();
 }
elseif (PyUnicode_Check(ps2_obj)) {
ps2=PyUnicode_AsUTF8(ps2_obj);
if (ps2==NULL) {
PyErr_Clear();
ps2="";
 }
 }
 }

interrcode=0;
*pmod=_PyParser_InteractiveASTFromFile(fp, filename, encoding,
Py_single_input, ps1, ps2,
flags, &errcode, interactive_src, arena);
Py_XDECREF(ps1_obj);
Py_XDECREF(ps2_obj);
Py_XDECREF(encoding_obj);

if (*pmod==NULL) {
if (errcode==E_EOF) {
PyErr_Clear();
returnE_EOF;
 }
return-1;
 }
return0;
}


/* A PyRun_InteractiveOneObject() auxiliary function that does not print the
 * error on failure. */
staticint
PyRun_InteractiveOneObjectEx(FILE*fp, PyObject*filename,
PyCompilerFlags*flags)
{
PyArena*arena=_PyArena_New();
if (arena==NULL) {
return-1;
 }

mod_tymod;
PyObject*interactive_src;
intparse_res=pyrun_one_parse_ast(fp, filename, flags, arena, &mod, &interactive_src);
if (parse_res!=0) {
_PyArena_Free(arena);
returnparse_res;
 }

PyObject*main_module=PyImport_AddModuleRef("__main__");
if (main_module==NULL) {
_PyArena_Free(arena);
return-1;
 }
PyObject*main_dict=PyModule_GetDict(main_module); // borrowed ref

PyObject*res=run_mod(mod, filename, main_dict, main_dict, flags, arena, interactive_src, 1);
Py_INCREF(interactive_src);
_PyArena_Free(arena);
Py_DECREF(main_module);
if (res==NULL) {
PyThreadState*tstate=_PyThreadState_GET();
PyObject*exc=_PyErr_GetRaisedException(tstate);
if (PyType_IsSubtype(Py_TYPE(exc),
 (PyTypeObject*) PyExc_SyntaxError))
 {
/* fix "text" attribute */
assert(interactive_src!=NULL);
PyObject*xs=PyUnicode_Splitlines(interactive_src, 1);
if (xs==NULL) {
 goto error;
 }
PyObject*exc_lineno=PyObject_GetAttr(exc, &_Py_ID(lineno));
if (exc_lineno==NULL) {
Py_DECREF(xs);
 goto error;
 }
intn=PyLong_AsInt(exc_lineno);
Py_DECREF(exc_lineno);
if (n <= 0||n>PyList_GET_SIZE(xs)) {
Py_DECREF(xs);
 goto error;
 }
PyObject*line=PyList_GET_ITEM(xs, n-1);
PyObject_SetAttr(exc, &_Py_ID(text), line);
Py_DECREF(xs);
 }
error:
Py_DECREF(interactive_src);
_PyErr_SetRaisedException(tstate, exc);
return-1;
 }
Py_DECREF(interactive_src);
Py_DECREF(res);

flush_io();
return0;
}

int
PyRun_InteractiveOneObject(FILE*fp, PyObject*filename, PyCompilerFlags*flags)
{
intres;

res=PyRun_InteractiveOneObjectEx(fp, filename, flags);
if (res==-1) {
PyErr_Print();
flush_io();
 }
returnres;
}

int
PyRun_InteractiveOneFlags(FILE*fp, constchar*filename_str, PyCompilerFlags*flags)
{
PyObject*filename;
intres;

filename=PyUnicode_DecodeFSDefault(filename_str);
if (filename==NULL) {
PyErr_Print();
return-1;
 }
res=PyRun_InteractiveOneObject(fp, filename, flags);
Py_DECREF(filename);
returnres;
}


/* Check whether a file maybe a pyc file: Look at the extension,
 the file type, and, if we may close it, at the first few bytes. */

staticint
maybe_pyc_file(FILE*fp, PyObject*filename, intcloseit)
{
PyObject*ext=PyUnicode_FromString(".pyc");
if (ext==NULL) {
return-1;
 }
Py_ssize_tendswith=PyUnicode_Tailmatch(filename, ext, 0, PY_SSIZE_T_MAX, +1);
Py_DECREF(ext);
if (endswith) {
return1;
 }

/* Only look into the file if we are allowed to close it, since
 it then should also be seekable. */
if (!closeit) {
return0;
 }

/* Read only two bytes of the magic. If the file was opened in
 text mode, the bytes 3 and 4 of the magic (\r\n) might not
 be read as they are on disk. */
unsigned inthalfmagic=PyImport_GetMagicNumber() &0xFFFF;
unsigned charbuf[2];
/* Mess: In case of -x, the stream is NOT at its start now,
 and ungetc() was used to push back the first newline,
 which makes the current stream position formally undefined,
 and a x-platform nightmare.
 Unfortunately, we have no direct way to know whether -x
 was specified. So we use a terrible hack: if the current
 stream position is not 0, we assume -x was specified, and
 give up. Bug 132850 on SourceForge spells out the
 hopelessness of trying anything else (fseek and ftell
 don't work predictably x-platform for text-mode files).
 */
intispyc=0;
if (ftell(fp) ==0) {
if (fread(buf, 1, 2, fp) ==2&&
 ((unsigned int)buf[1]<<8 | buf[0]) ==halfmagic)
ispyc=1;
rewind(fp);
 }
returnispyc;
}


staticint
set_main_loader(PyObject*d, PyObject*filename, constchar*loader_name)
{
PyInterpreterState*interp=_PyInterpreterState_GET();
PyObject*loader_type=_PyImport_GetImportlibExternalLoader(interp,
loader_name);
if (loader_type==NULL) {
return-1;
 }

PyObject*loader=PyObject_CallFunction(loader_type,
"sO", "__main__", filename);
Py_DECREF(loader_type);
if (loader==NULL) {
return-1;
 }

if (PyDict_SetItemString(d, "__loader__", loader) <0) {
Py_DECREF(loader);
return-1;
 }
Py_DECREF(loader);
return0;
}


int
_PyRun_SimpleFileObject(FILE*fp, PyObject*filename, intcloseit,
PyCompilerFlags*flags)
{
intret=-1;

PyObject*main_module=PyImport_AddModuleRef("__main__");
if (main_module==NULL)
return-1;
PyObject*dict=PyModule_GetDict(main_module); // borrowed ref

intset_file_name=0;
inthas_file=PyDict_ContainsString(dict, "__file__");
if (has_file<0) {
 goto done;
 }
if (!has_file) {
if (PyDict_SetItemString(dict, "__file__", filename) <0) {
 goto done;
 }
if (PyDict_SetItemString(dict, "__cached__", Py_None) <0) {
 goto done;
 }
set_file_name=1;
 }

intpyc=maybe_pyc_file(fp, filename, closeit);
if (pyc<0) {
 goto done;
 }

PyObject*v;
if (pyc) {
FILE*pyc_fp;
/* Try to run a pyc file. First, re-open in binary */
if (closeit) {
fclose(fp);
 }

pyc_fp=_Py_fopen_obj(filename, "rb");
if (pyc_fp==NULL) {
fprintf(stderr, "python: Can't reopen .pyc file\n");
 goto done;
 }

if (set_main_loader(dict, filename, "SourcelessFileLoader") <0) {
fprintf(stderr, "python: failed to set __main__.__loader__\n");
ret=-1;
fclose(pyc_fp);
 goto done;
 }
v=run_pyc_file(pyc_fp, dict, dict, flags);
 } else {
/* When running from stdin, leave __main__.__loader__ alone */
if ((!PyUnicode_Check(filename) || !PyUnicode_EqualToUTF8(filename, "<stdin>")) &&
set_main_loader(dict, filename, "SourceFileLoader") <0) {
fprintf(stderr, "python: failed to set __main__.__loader__\n");
ret=-1;
 goto done;
 }
v=pyrun_file(fp, filename, Py_file_input, dict, dict,
closeit, flags);
 }
flush_io();
if (v==NULL) {
Py_CLEAR(main_module);
PyErr_Print();
 goto done;
 }
Py_DECREF(v);
ret=0;

done:
if (set_file_name) {
if (PyDict_PopString(dict, "__file__", NULL) <0) {
PyErr_Print();
 }
if (PyDict_PopString(dict, "__cached__", NULL) <0) {
PyErr_Print();
 }
 }
Py_XDECREF(main_module);
returnret;
}


int
PyRun_SimpleFileExFlags(FILE*fp, constchar*filename, intcloseit,
PyCompilerFlags*flags)
{
PyObject*filename_obj=PyUnicode_DecodeFSDefault(filename);
if (filename_obj==NULL) {
return-1;
 }
intres=_PyRun_SimpleFileObject(fp, filename_obj, closeit, flags);
Py_DECREF(filename_obj);
returnres;
}


int
_PyRun_SimpleStringFlagsWithName(constchar*command, constchar*name, PyCompilerFlags*flags) {
PyObject*main_module=PyImport_AddModuleRef("__main__");
if (main_module==NULL) {
return-1;
 }
PyObject*dict=PyModule_GetDict(main_module); // borrowed ref

PyObject*res=NULL;
if (name==NULL) {
res=PyRun_StringFlags(command, Py_file_input, dict, dict, flags);
 } else {
PyObject*the_name=PyUnicode_FromString(name);
if (!the_name) {
PyErr_Print();
return-1;
 }
res=_PyRun_StringFlagsWithName(command, the_name, Py_file_input, dict, dict, flags, 0);
Py_DECREF(the_name);
 }
Py_DECREF(main_module);
if (res==NULL) {
PyErr_Print();
return-1;
 }

Py_DECREF(res);
return0;
}

int
PyRun_SimpleStringFlags(constchar*command, PyCompilerFlags*flags)
{
return_PyRun_SimpleStringFlagsWithName(command, NULL, flags);
}

staticint
parse_exit_code(PyObject*code, int*exitcode_p)
{
if (PyLong_Check(code)) {
// gh-125842: Use a long long to avoid an overflow error when `long`
// is 32-bit. We still truncate the result to an int.
intexitcode= (int)PyLong_AsLongLong(code);
if (exitcode==-1&&PyErr_Occurred()) {
// On overflow or other error, clear the exception and use -1
// as the exit code to match historical Python behavior.
PyErr_Clear();
*exitcode_p=-1;
return1;
 }
*exitcode_p=exitcode;
return1;
 }
elseif (code==Py_None) {
*exitcode_p=0;
return1;
 }
return0;
}

int
_Py_HandleSystemExit(int*exitcode_p)
{
intinspect=_Py_GetConfig()->inspect;
if (inspect) {
/* Don't exit if -i flag was given. This flag is set to 0
 * when entering interactive mode for inspecting. */
return0;
 }

if (!PyErr_ExceptionMatches(PyExc_SystemExit)) {
return0;
 }

fflush(stdout);

PyObject*exc=PyErr_GetRaisedException();
assert(exc!=NULL&&PyExceptionInstance_Check(exc));

PyObject*code=PyObject_GetAttr(exc, &_Py_ID(code));
if (code==NULL) {
// If the exception has no 'code' attribute, print the exception below
PyErr_Clear();
 }
elseif (parse_exit_code(code, exitcode_p)) {
Py_DECREF(code);
Py_CLEAR(exc);
return1;
 }
else {
// If code is not an int or None, print it below
Py_SETREF(exc, code);
 }

PyObject*sys_stderr;
if (_PySys_GetOptionalAttr(&_Py_ID(stderr), &sys_stderr) <0) {
PyErr_Clear();
 }
elseif (sys_stderr!=NULL&&sys_stderr!=Py_None) {
if (PyFile_WriteObject(exc, sys_stderr, Py_PRINT_RAW) <0) {
PyErr_Clear();
 }
 }
else {
if (PyObject_Print(exc, stderr, Py_PRINT_RAW) <0) {
PyErr_Clear();
 }
fflush(stderr);
 }
PySys_WriteStderr("\n");
Py_XDECREF(sys_stderr);
Py_CLEAR(exc);
*exitcode_p=1;
return1;
}


staticvoid
handle_system_exit(void)
{
intexitcode;
if (_Py_HandleSystemExit(&exitcode)) {
Py_Exit(exitcode);
 }
}


staticvoid
_PyErr_PrintEx(PyThreadState*tstate, intset_sys_last_vars)
{
PyObject*typ=NULL, *tb=NULL, *hook=NULL;
handle_system_exit();

PyObject*exc=_PyErr_GetRaisedException(tstate);
if (exc==NULL) {
 goto done;
 }
assert(PyExceptionInstance_Check(exc));
typ=Py_NewRef(Py_TYPE(exc));
tb=PyException_GetTraceback(exc);
if (tb==NULL) {
tb=Py_NewRef(Py_None);
 }

if (set_sys_last_vars) {
if (_PySys_SetAttr(&_Py_ID(last_exc), exc) <0) {
_PyErr_Clear(tstate);
 }
/* Legacy version: */
if (_PySys_SetAttr(&_Py_ID(last_type), typ) <0) {
_PyErr_Clear(tstate);
 }
if (_PySys_SetAttr(&_Py_ID(last_value), exc) <0) {
_PyErr_Clear(tstate);
 }
if (_PySys_SetAttr(&_Py_ID(last_traceback), tb) <0) {
_PyErr_Clear(tstate);
 }
 }
if (_PySys_GetOptionalAttr(&_Py_ID(excepthook), &hook) <0) {
PyErr_Clear();
 }
if (_PySys_Audit(tstate, "sys.excepthook", "OOOO", hook ? hook : Py_None,
typ, exc, tb) <0) {
if (PyErr_ExceptionMatches(PyExc_RuntimeError)) {
PyErr_Clear();
 goto done;
 }
PyErr_FormatUnraisable("Exception ignored in audit hook");
 }
if (hook) {
PyObject*args[3] = {typ, exc, tb};
PyObject*result=PyObject_Vectorcall(hook, args, 3, NULL);
if (result==NULL) {
handle_system_exit();

PyObject*exc2=_PyErr_GetRaisedException(tstate);
assert(exc2&&PyExceptionInstance_Check(exc2));
fflush(stdout);
PySys_WriteStderr("Error in sys.excepthook:\n");
PyErr_DisplayException(exc2);
PySys_WriteStderr("\nOriginal exception was:\n");
PyErr_DisplayException(exc);
Py_DECREF(exc2);
 }
else {
Py_DECREF(result);
 }
 }
else {
PySys_WriteStderr("sys.excepthook is missing\n");
PyErr_DisplayException(exc);
 }

done:
Py_XDECREF(hook);
Py_XDECREF(typ);
Py_XDECREF(exc);
Py_XDECREF(tb);
}

void
_PyErr_Print(PyThreadState*tstate)
{
_PyErr_PrintEx(tstate, 1);
}

void
PyErr_PrintEx(intset_sys_last_vars)
{
PyThreadState*tstate=_PyThreadState_GET();
_PyErr_PrintEx(tstate, set_sys_last_vars);
}

void
PyErr_Print(void)
{
PyErr_PrintEx(1);
}

structexception_print_context
{
PyObject*file;
PyObject*seen; // Prevent cycles in recursion
};

staticint
print_exception_invalid_type(structexception_print_context*ctx,
PyObject*value)
{
PyObject*f=ctx->file;
constchar*constmsg="TypeError: print_exception(): Exception expected "
"for value, ";
if (PyFile_WriteString(msg, f) <0) {
return-1;
 }
if (PyFile_WriteString(Py_TYPE(value)->tp_name, f) <0) {
return-1;
 }
if (PyFile_WriteString(" found\n", f) <0) {
return-1;
 }
return0;
}

staticint
print_exception_traceback(structexception_print_context*ctx, PyObject*value)
{
PyObject*f=ctx->file;
interr=0;

PyObject*tb=PyException_GetTraceback(value);
if (tb&&tb!=Py_None) {
constchar*header=EXCEPTION_TB_HEADER;
err=_PyTraceBack_Print(tb, header, f);
 }
Py_XDECREF(tb);
returnerr;
}

staticint
print_exception_file_and_line(structexception_print_context*ctx,
PyObject**value_p)
{
PyObject*f=ctx->file;

PyObject*tmp;
intres=PyObject_GetOptionalAttr(*value_p, &_Py_ID(print_file_and_line), &tmp);
if (res <= 0) {
if (res<0) {
PyErr_Clear();
 }
return0;
 }
Py_DECREF(tmp);

PyObject*filename=NULL;
Py_ssize_tlineno=0;
PyObject*v=PyObject_GetAttr(*value_p, &_Py_ID(filename));
if (!v) {
return-1;
 }
if (v==Py_None) {
Py_DECREF(v);
_Py_DECLARE_STR(anon_string, "<string>");
filename=Py_NewRef(&_Py_STR(anon_string));
 }
else {
filename=v;
 }

PyObject*line=PyUnicode_FromFormat(" File \"%S\", line %zd\n",
filename, lineno);
Py_DECREF(filename);
if (line==NULL) {
 goto error;
 }
if (PyFile_WriteObject(line, f, Py_PRINT_RAW) <0) {
 goto error;
 }
Py_CLEAR(line);

assert(!PyErr_Occurred());
return0;

error:
Py_XDECREF(line);
return-1;
}

/* Prints the message line: module.qualname[: str(exc)] */
staticint
print_exception_message(structexception_print_context*ctx, PyObject*type,
PyObject*value)
{
PyObject*f=ctx->file;

if (PyErr_GivenExceptionMatches(value, PyExc_MemoryError)) {
// The Python APIs in this function require allocating memory
// for various objects. If we're out of memory, we can't do that,
return-1;
 }

assert(PyExceptionClass_Check(type));

PyObject*modulename=PyObject_GetAttr(type, &_Py_ID(__module__));
if (modulename==NULL|| !PyUnicode_Check(modulename)) {
Py_XDECREF(modulename);
PyErr_Clear();
if (PyFile_WriteString("<unknown>.", f) <0) {
return-1;
 }
 }
else {
if (!_PyUnicode_Equal(modulename, &_Py_ID(builtins)) &&
 !_PyUnicode_Equal(modulename, &_Py_ID(__main__)))
 {
intres=PyFile_WriteObject(modulename, f, Py_PRINT_RAW);
Py_DECREF(modulename);
if (res<0) {
return-1;
 }
if (PyFile_WriteString(".", f) <0) {
return-1;
 }
 }
else {
Py_DECREF(modulename);
 }
 }

PyObject*qualname=PyType_GetQualName((PyTypeObject*)type);
if (qualname==NULL|| !PyUnicode_Check(qualname)) {
Py_XDECREF(qualname);
PyErr_Clear();
if (PyFile_WriteString("<unknown>", f) <0) {
return-1;
 }
 }
else {
intres=PyFile_WriteObject(qualname, f, Py_PRINT_RAW);
Py_DECREF(qualname);
if (res<0) {
return-1;
 }
 }

if (Py_IsNone(value)) {
return0;
 }

PyObject*s=PyObject_Str(value);
if (s==NULL) {
PyErr_Clear();
if (PyFile_WriteString(": <exception str() failed>", f) <0) {
return-1;
 }
 }
else {
/* only print colon if the str() of the
 object is not the empty string
 */
if (!PyUnicode_Check(s) ||PyUnicode_GetLength(s) !=0) {
if (PyFile_WriteString(": ", f) <0) {
Py_DECREF(s);
return-1;
 }
 }
intres=PyFile_WriteObject(s, f, Py_PRINT_RAW);
Py_DECREF(s);
if (res<0) {
return-1;
 }
 }

return0;
}

staticint
print_exception(structexception_print_context*ctx, PyObject*value)
{
PyObject*f=ctx->file;

if (!PyExceptionInstance_Check(value)) {
returnprint_exception_invalid_type(ctx, value);
 }

Py_INCREF(value);
fflush(stdout);

if (print_exception_traceback(ctx, value) <0) {
 goto error;
 }

/* grab the type and notes now because value can change below */
PyObject*type= (PyObject*) Py_TYPE(value);

if (print_exception_file_and_line(ctx, &value) <0) {
 goto error;
 }
if (print_exception_message(ctx, type, value) <0) {
 goto error;
 }
if (PyFile_WriteString("\n", f) <0) {
 goto error;
 }
Py_DECREF(value);
assert(!PyErr_Occurred());
return0;
error:
Py_DECREF(value);
return-1;
}

staticconstcharcause_message[] =
"The above exception was the direct cause "
"of the following exception:\n";

staticconstcharcontext_message[] =
"During handling of the above exception, "
"another exception occurred:\n";

staticint
print_exception_recursive(structexception_print_context*, PyObject*);