crossinterp.c

/* API for managing interactions between isolated interpreters */

#include"Python.h"
#include"pycore_ceval.h"// _Py_simple_func
#include"pycore_crossinterp.h"// struct _xid
#include"pycore_initconfig.h"// _PyStatus_OK()
#include"pycore_namespace.h"//_PyNamespace_New()
#include"pycore_pyerrors.h"// _PyErr_Clear()
#include"pycore_weakref.h"// _PyWeakref_GET_REF()


/**************/
/* exceptions */
/**************/

staticintinit_exceptions(PyInterpreterState*);
staticvoidfini_exceptions(PyInterpreterState*);
staticint_init_not_shareable_error_type(PyInterpreterState*);
staticvoid_fini_not_shareable_error_type(PyInterpreterState*);
staticPyObject*_get_not_shareable_error_type(PyInterpreterState*);
#include"crossinterp_exceptions.h"


/***************************/
/* cross-interpreter calls */
/***************************/

int
_Py_CallInInterpreter(PyInterpreterState*interp,
_Py_simple_funcfunc, void*arg)
{
if (interp==PyInterpreterState_Get()) {
returnfunc(arg);
 }
// XXX Emit a warning if this fails?
_PyEval_AddPendingCall(interp, (_Py_pending_call_func)func, arg, 0);
return0;
}

int
_Py_CallInInterpreterAndRawFree(PyInterpreterState*interp,
_Py_simple_funcfunc, void*arg)
{
if (interp==PyInterpreterState_Get()) {
intres=func(arg);
PyMem_RawFree(arg);
returnres;
 }
// XXX Emit a warning if this fails?
_PyEval_AddPendingCall(interp, func, arg, _Py_PENDING_RAWFREE);
return0;
}


/**************************/
/* cross-interpreter data */
/**************************/

/* registry of {type -> crossinterpdatafunc} */

/* For now we use a global registry of shareable classes. An
 alternative would be to add a tp_* slot for a class's
 crossinterpdatafunc. It would be simpler and more efficient. */

staticvoidxid_lookup_init(PyInterpreterState*);
staticvoidxid_lookup_fini(PyInterpreterState*);
staticcrossinterpdatafunclookup_getdata(PyInterpreterState*, PyObject*);
#include"crossinterp_data_lookup.h"


/* lifecycle */

_PyCrossInterpreterData*
_PyCrossInterpreterData_New(void)
{
_PyCrossInterpreterData*xid=PyMem_RawMalloc(
sizeof(_PyCrossInterpreterData));
if (xid==NULL) {
PyErr_NoMemory();
 }
returnxid;
}

void
_PyCrossInterpreterData_Free(_PyCrossInterpreterData*xid)
{
PyInterpreterState*interp=PyInterpreterState_Get();
_PyCrossInterpreterData_Clear(interp, xid);
PyMem_RawFree(xid);
}


/* defining cross-interpreter data */

staticinlinevoid
_xidata_init(_PyCrossInterpreterData*data)
{
// If the value is being reused
// then _xidata_clear() should have been called already.
assert(data->data==NULL);
assert(data->obj==NULL);
*data= (_PyCrossInterpreterData){0};
_PyCrossInterpreterData_INTERPID(data) =-1;
}

staticinlinevoid
_xidata_clear(_PyCrossInterpreterData*data)
{
// _PyCrossInterpreterData only has two members that need to be
// cleaned up, if set: "data" must be freed and "obj" must be decref'ed.
// In both cases the original (owning) interpreter must be used,
// which is the caller's responsibility to ensure.
if (data->data!=NULL) {
if (data->free!=NULL) {
data->free(data->data);
 }
data->data=NULL;
 }
Py_CLEAR(data->obj);
}

void
_PyCrossInterpreterData_Init(_PyCrossInterpreterData*data,
PyInterpreterState*interp,
void*shared, PyObject*obj,
xid_newobjectfuncnew_object)
{
assert(data!=NULL);
assert(new_object!=NULL);
_xidata_init(data);
data->data=shared;
if (obj!=NULL) {
assert(interp!=NULL);
// released in _PyCrossInterpreterData_Clear()
data->obj=Py_NewRef(obj);
 }
// Ideally every object would know its owning interpreter.
// Until then, we have to rely on the caller to identify it
// (but we don't need it in all cases).
_PyCrossInterpreterData_INTERPID(data) = (interp!=NULL)
 ? PyInterpreterState_GetID(interp)
 : -1;
data->new_object=new_object;
}

int
_PyCrossInterpreterData_InitWithSize(_PyCrossInterpreterData*data,
PyInterpreterState*interp,
constsize_tsize, PyObject*obj,
xid_newobjectfuncnew_object)
{
assert(size>0);
// For now we always free the shared data in the same interpreter
// where it was allocated, so the interpreter is required.
assert(interp!=NULL);
_PyCrossInterpreterData_Init(data, interp, NULL, obj, new_object);
data->data=PyMem_RawMalloc(size);
if (data->data==NULL) {
return-1;
 }
data->free=PyMem_RawFree;
return0;
}

void
_PyCrossInterpreterData_Clear(PyInterpreterState*interp,
_PyCrossInterpreterData*data)
{
assert(data!=NULL);
// This must be called in the owning interpreter.
assert(interp==NULL
||_PyCrossInterpreterData_INTERPID(data) ==-1
||_PyCrossInterpreterData_INTERPID(data) ==PyInterpreterState_GetID(interp));
_xidata_clear(data);
}


/* using cross-interpreter data */

staticint
_check_xidata(PyThreadState*tstate, _PyCrossInterpreterData*data)
{
// data->data can be anything, including NULL, so we don't check it.

// data->obj may be NULL, so we don't check it.

if (_PyCrossInterpreterData_INTERPID(data) <0) {
PyErr_SetString(PyExc_SystemError, "missing interp");
return-1;
 }

if (data->new_object==NULL) {
PyErr_SetString(PyExc_SystemError, "missing new_object func");
return-1;
 }

// data->free may be NULL, so we don't check it.

return0;
}

staticinlinevoid
_set_xid_lookup_failure(PyInterpreterState*interp,
PyObject*obj, constchar*msg)
{
PyObject*exctype=_get_not_shareable_error_type(interp);
assert(exctype!=NULL);
if (msg!=NULL) {
assert(obj==NULL);
PyErr_SetString(exctype, msg);
 }
elseif (obj==NULL) {
PyErr_SetString(exctype,
"object does not support cross-interpreter data");
 }
else {
PyErr_Format(exctype,
"%S does not support cross-interpreter data", obj);
 }
}

int
_PyObject_CheckCrossInterpreterData(PyObject*obj)
{
PyInterpreterState*interp=PyInterpreterState_Get();
crossinterpdatafuncgetdata=lookup_getdata(interp, obj);
if (getdata==NULL) {
if (!PyErr_Occurred()) {
_set_xid_lookup_failure(interp, obj, NULL);
 }
return-1;
 }
return0;
}

int
_PyObject_GetCrossInterpreterData(PyObject*obj, _PyCrossInterpreterData*data)
{
PyThreadState*tstate=PyThreadState_Get();
PyInterpreterState*interp=tstate->interp;

// Reset data before re-populating.
*data= (_PyCrossInterpreterData){0};
_PyCrossInterpreterData_INTERPID(data) =-1;

// Call the "getdata" func for the object.
Py_INCREF(obj);
crossinterpdatafuncgetdata=lookup_getdata(interp, obj);
if (getdata==NULL) {
Py_DECREF(obj);
if (!PyErr_Occurred()) {
_set_xid_lookup_failure(interp, obj, NULL);
 }
return-1;
 }
intres=getdata(tstate, obj, data);
Py_DECREF(obj);
if (res!=0) {
return-1;
 }

// Fill in the blanks and validate the result.
_PyCrossInterpreterData_INTERPID(data) =PyInterpreterState_GetID(interp);
if (_check_xidata(tstate, data) !=0) {
 (void)_PyCrossInterpreterData_Release(data);
return-1;
 }

return0;
}

PyObject*
_PyCrossInterpreterData_NewObject(_PyCrossInterpreterData*data)
{
returndata->new_object(data);
}

staticint
_call_clear_xidata(void*data)
{
_xidata_clear((_PyCrossInterpreterData*)data);
return0;
}

staticint
_xidata_release(_PyCrossInterpreterData*data, intrawfree)
{
if ((data->data==NULL||data->free==NULL) &&data->obj==NULL) {
// Nothing to release!
if (rawfree) {
PyMem_RawFree(data);
 }
else {
data->data=NULL;
 }
return0;
 }

// Switch to the original interpreter.
PyInterpreterState*interp=_PyInterpreterState_LookUpID(
_PyCrossInterpreterData_INTERPID(data));
if (interp==NULL) {
// The interpreter was already destroyed.
// This function shouldn't have been called.
// XXX Someone leaked some memory...
assert(PyErr_Occurred());
if (rawfree) {
PyMem_RawFree(data);
 }
return-1;
 }

// "Release" the data and/or the object.
if (rawfree) {
return_Py_CallInInterpreterAndRawFree(interp, _call_clear_xidata, data);
 }
else {
return_Py_CallInInterpreter(interp, _call_clear_xidata, data);
 }
}

int
_PyCrossInterpreterData_Release(_PyCrossInterpreterData*data)
{
return_xidata_release(data, 0);
}

int
_PyCrossInterpreterData_ReleaseAndRawFree(_PyCrossInterpreterData*data)
{
return_xidata_release(data, 1);
}


/*************************/
/* convenience utilities */
/*************************/

staticconstchar*
_copy_string_obj_raw(PyObject*strobj, Py_ssize_t*p_size)
{
Py_ssize_tsize=-1;
constchar*str=PyUnicode_AsUTF8AndSize(strobj, &size);
if (str==NULL) {
returnNULL;
 }

if (size!= (Py_ssize_t)strlen(str)) {
PyErr_SetString(PyExc_ValueError, "found embedded NULL character");
returnNULL;
 }

char*copied=PyMem_RawMalloc(size+1);
if (copied==NULL) {
PyErr_NoMemory();
returnNULL;
 }
strcpy(copied, str);
if (p_size!=NULL) {
*p_size=size;
 }
returncopied;
}


staticint
_convert_exc_to_TracebackException(PyObject*exc, PyObject**p_tbexc)
{
PyObject*args=NULL;
PyObject*kwargs=NULL;
PyObject*create=NULL;

// This is inspired by _PyErr_Display().
PyObject*tbmod=PyImport_ImportModule("traceback");
if (tbmod==NULL) {
return-1;
 }
PyObject*tbexc_type=PyObject_GetAttrString(tbmod, "TracebackException");
Py_DECREF(tbmod);
if (tbexc_type==NULL) {
return-1;
 }
create=PyObject_GetAttrString(tbexc_type, "from_exception");
Py_DECREF(tbexc_type);
if (create==NULL) {
return-1;
 }

args=PyTuple_Pack(1, exc);
if (args==NULL) {
 goto error;
 }

kwargs=PyDict_New();
if (kwargs==NULL) {
 goto error;
 }
if (PyDict_SetItemString(kwargs, "save_exc_type", Py_False) <0) {
 goto error;
 }
if (PyDict_SetItemString(kwargs, "lookup_lines", Py_False) <0) {
 goto error;
 }

PyObject*tbexc=PyObject_Call(create, args, kwargs);
Py_DECREF(args);
Py_DECREF(kwargs);
Py_DECREF(create);
if (tbexc==NULL) {
 goto error;
 }

*p_tbexc=tbexc;
return0;

error:
Py_XDECREF(args);
Py_XDECREF(kwargs);
Py_XDECREF(create);
return-1;
}

// We accommodate backports here.
#ifndef_Py_EMPTY_STR
# define_Py_EMPTY_STR &_Py_STR(empty)
#endif

staticconstchar*
_format_TracebackException(PyObject*tbexc)
{
PyObject*lines=PyObject_CallMethod(tbexc, "format", NULL);
if (lines==NULL) {
returnNULL;
 }
assert(_Py_EMPTY_STR!=NULL);
PyObject*formatted_obj=PyUnicode_Join(_Py_EMPTY_STR, lines);
Py_DECREF(lines);
if (formatted_obj==NULL) {
returnNULL;
 }

Py_ssize_tsize=-1;
constchar*formatted=_copy_string_obj_raw(formatted_obj, &size);
Py_DECREF(formatted_obj);
// We remove trailing the newline added by TracebackException.format().
assert(formatted[size-1] =='\n');
 ((char*)formatted)[size-1] ='\0';
returnformatted;
}


staticint
_release_xid_data(_PyCrossInterpreterData*data, intrawfree)
{
PyObject*exc=PyErr_GetRaisedException();
intres=rawfree
 ? _PyCrossInterpreterData_Release(data)
 : _PyCrossInterpreterData_ReleaseAndRawFree(data);
if (res<0) {
/* The owning interpreter is already destroyed. */
_PyCrossInterpreterData_Clear(NULL, data);
// XXX Emit a warning?
PyErr_Clear();
 }
PyErr_SetRaisedException(exc);
returnres;
}


/***********************/
/* exception snapshots */
/***********************/

staticint
_excinfo_init_type_from_exception(struct_excinfo_type*info, PyObject*exc)
{
/* Note that this copies directly rather than into an intermediate
 struct and does not clear on error. If we need that then we
 should have a separate function to wrap this one
 and do all that there. */
PyObject*strobj=NULL;

PyTypeObject*type=Py_TYPE(exc);
if (type->tp_flags&_Py_TPFLAGS_STATIC_BUILTIN) {
assert(_Py_IsImmortal((PyObject*)type));
info->builtin=type;
 }
else {
// Only builtin types are preserved.
info->builtin=NULL;
 }

// __name__
strobj=PyType_GetName(type);
if (strobj==NULL) {
return-1;
 }
info->name=_copy_string_obj_raw(strobj, NULL);
Py_DECREF(strobj);
if (info->name==NULL) {
return-1;
 }

// __qualname__
strobj=PyType_GetQualName(type);
if (strobj==NULL) {
return-1;
 }
info->qualname=_copy_string_obj_raw(strobj, NULL);
Py_DECREF(strobj);
if (info->qualname==NULL) {
return-1;
 }

// __module__
strobj=PyType_GetModuleName(type);
if (strobj==NULL) {
return-1;
 }
info->module=_copy_string_obj_raw(strobj, NULL);
Py_DECREF(strobj);
if (info->module==NULL) {
return-1;
 }

return0;
}

staticint
_excinfo_init_type_from_object(struct_excinfo_type*info, PyObject*exctype)
{
PyObject*strobj=NULL;

// __name__
strobj=PyObject_GetAttrString(exctype, "__name__");
if (strobj==NULL) {
return-1;
 }
info->name=_copy_string_obj_raw(strobj, NULL);
Py_DECREF(strobj);
if (info->name==NULL) {
return-1;
 }

// __qualname__
strobj=PyObject_GetAttrString(exctype, "__qualname__");
if (strobj==NULL) {
return-1;
 }
info->qualname=_copy_string_obj_raw(strobj, NULL);
Py_DECREF(strobj);
if (info->qualname==NULL) {
return-1;
 }

// __module__
strobj=PyObject_GetAttrString(exctype, "__module__");
if (strobj==NULL) {
return-1;
 }
info->module=_copy_string_obj_raw(strobj, NULL);
Py_DECREF(strobj);
if (info->module==NULL) {
return-1;
 }

return0;
}

staticvoid
_excinfo_clear_type(struct_excinfo_type*info)
{
if (info->builtin!=NULL) {
assert(info->builtin->tp_flags&_Py_TPFLAGS_STATIC_BUILTIN);
assert(_Py_IsImmortal((PyObject*)info->builtin));
 }
if (info->name!=NULL) {
PyMem_RawFree((void*)info->name);
 }
if (info->qualname!=NULL) {
PyMem_RawFree((void*)info->qualname);
 }
if (info->module!=NULL) {
PyMem_RawFree((void*)info->module);
 }
*info= (struct_excinfo_type){NULL};
}

staticvoid
_excinfo_normalize_type(struct_excinfo_type*info,
constchar**p_module, constchar**p_qualname)
{
if (info->name==NULL) {
assert(info->builtin==NULL);
assert(info->qualname==NULL);
assert(info->module==NULL);
// This is inspired by TracebackException.format_exception_only().
*p_module=NULL;
*p_qualname=NULL;
return;
 }

constchar*module=info->module;
constchar*qualname=info->qualname;
if (qualname==NULL) {
qualname=info->name;
 }
assert(module!=NULL);
if (strcmp(module, "builtins") ==0) {
module=NULL;
 }
elseif (strcmp(module, "__main__") ==0) {
module=NULL;
 }
*p_qualname=qualname;
*p_module=module;
}

staticvoid
_PyXI_excinfo_Clear(_PyXI_excinfo*info)
{
_excinfo_clear_type(&info->type);
if (info->msg!=NULL) {
PyMem_RawFree((void*)info->msg);
 }
if (info->errdisplay!=NULL) {
PyMem_RawFree((void*)info->errdisplay);
 }
*info= (_PyXI_excinfo){{NULL}};
}

PyObject*
_PyXI_excinfo_format(_PyXI_excinfo*info)
{
constchar*module, *qualname;
_excinfo_normalize_type(&info->type, &module, &qualname);
if (qualname!=NULL) {
if (module!=NULL) {
if (info->msg!=NULL) {
returnPyUnicode_FromFormat("%s.%s: %s",
module, qualname, info->msg);
 }
else {
returnPyUnicode_FromFormat("%s.%s", module, qualname);
 }
 }
else {
if (info->msg!=NULL) {
returnPyUnicode_FromFormat("%s: %s", qualname, info->msg);
 }
else {
returnPyUnicode_FromString(qualname);
 }
 }
 }
elseif (info->msg!=NULL) {
returnPyUnicode_FromString(info->msg);
 }
else {
Py_RETURN_NONE;
 }
}

staticconstchar*
_PyXI_excinfo_InitFromException(_PyXI_excinfo*info, PyObject*exc)
{
assert(exc!=NULL);

if (PyErr_GivenExceptionMatches(exc, PyExc_MemoryError)) {
_PyXI_excinfo_Clear(info);
returnNULL;
 }
constchar*failure=NULL;

if (_excinfo_init_type_from_exception(&info->type, exc) <0) {
failure="error while initializing exception type snapshot";
 goto error;
 }

// Extract the exception message.
PyObject*msgobj=PyObject_Str(exc);
if (msgobj==NULL) {
failure="error while formatting exception";
 goto error;
 }
info->msg=_copy_string_obj_raw(msgobj, NULL);
Py_DECREF(msgobj);
if (info->msg==NULL) {
failure="error while copying exception message";
 goto error;
 }

// Pickle a traceback.TracebackException.
PyObject*tbexc=NULL;
if (_convert_exc_to_TracebackException(exc, &tbexc) <0) {
#ifdefPy_DEBUG
PyErr_FormatUnraisable("Exception ignored while creating TracebackException");
#endif
PyErr_Clear();
 }
else {
info->errdisplay=_format_TracebackException(tbexc);
Py_DECREF(tbexc);
if (info->errdisplay==NULL) {
#ifdefPy_DEBUG
PyErr_FormatUnraisable("Exception ignored while formatting TracebackException");
#endif
PyErr_Clear();
 }
 }

returnNULL;

error:
assert(failure!=NULL);
_PyXI_excinfo_Clear(info);
returnfailure;
}

staticconstchar*
_PyXI_excinfo_InitFromObject(_PyXI_excinfo*info, PyObject*obj)
{
constchar*failure=NULL;

PyObject*exctype=PyObject_GetAttrString(obj, "type");
if (exctype==NULL) {
failure="exception snapshot missing 'type' attribute";
 goto error;
 }
intres=_excinfo_init_type_from_object(&info->type, exctype);
Py_DECREF(exctype);
if (res<0) {
failure="error while initializing exception type snapshot";
 goto error;
 }

// Extract the exception message.
PyObject*msgobj=PyObject_GetAttrString(obj, "msg");
if (msgobj==NULL) {
failure="exception snapshot missing 'msg' attribute";
 goto error;
 }
info->msg=_copy_string_obj_raw(msgobj, NULL);
Py_DECREF(msgobj);
if (info->msg==NULL) {
failure="error while copying exception message";
 goto error;
 }

// Pickle a traceback.TracebackException.
PyObject*errdisplay=PyObject_GetAttrString(obj, "errdisplay");
if (errdisplay==NULL) {
failure="exception snapshot missing 'errdisplay' attribute";
 goto error;
 }
info->errdisplay=_copy_string_obj_raw(errdisplay, NULL);
Py_DECREF(errdisplay);
if (info->errdisplay==NULL) {
failure="error while copying exception error display";
 goto error;
 }

returnNULL;

error:
assert(failure!=NULL);
_PyXI_excinfo_Clear(info);
returnfailure;
}

staticvoid
_PyXI_excinfo_Apply(_PyXI_excinfo*info, PyObject*exctype)
{
PyObject*tbexc=NULL;
if (info->errdisplay!=NULL) {
tbexc=PyUnicode_FromString(info->errdisplay);
if (tbexc==NULL) {
PyErr_Clear();
 }
 }

PyObject*formatted=_PyXI_excinfo_format(info);
PyErr_SetObject(exctype, formatted);
Py_DECREF(formatted);

if (tbexc!=NULL) {
PyObject*exc=PyErr_GetRaisedException();
if (PyObject_SetAttrString(exc, "_errdisplay", tbexc) <0) {
#ifdefPy_DEBUG
PyErr_FormatUnraisable("Exception ignored when setting _errdisplay");
#endif
PyErr_Clear();
 }
Py_DECREF(tbexc);
PyErr_SetRaisedException(exc);
 }
}

staticPyObject*
_PyXI_excinfo_TypeAsObject(_PyXI_excinfo*info)
{
PyObject*ns=_PyNamespace_New(NULL);
if (ns==NULL) {
returnNULL;
 }
intempty=1;

if (info->type.name!=NULL) {
PyObject*name=PyUnicode_FromString(info->type.name);
if (name==NULL) {
 goto error;
 }
intres=PyObject_SetAttrString(ns, "__name__", name);
Py_DECREF(name);
if (res<0) {
 goto error;
 }
empty=0;
 }

if (info->type.qualname!=NULL) {
PyObject*qualname=PyUnicode_FromString(info->type.qualname);
if (qualname==NULL) {
 goto error;
 }
intres=PyObject_SetAttrString(ns, "__qualname__", qualname);
Py_DECREF(qualname);
if (res<0) {
 goto error;
 }
empty=0;
 }

if (info->type.module!=NULL) {
PyObject*module=PyUnicode_FromString(info->type.module);
if (module==NULL) {
 goto error;
 }
intres=PyObject_SetAttrString(ns, "__module__", module);
Py_DECREF(module);
if (res<0) {
 goto error;
 }
empty=0;
 }

if (empty) {
Py_CLEAR(ns);
 }

returnns;

error:
Py_DECREF(ns);
returnNULL;
}

staticPyObject*
_PyXI_excinfo_AsObject(_PyXI_excinfo*info)
{
PyObject*ns=_PyNamespace_New(NULL);
if (ns==NULL) {
returnNULL;
 }
intres;

PyObject*type=_PyXI_excinfo_TypeAsObject(info);
if (type==NULL) {
if (PyErr_Occurred()) {
 goto error;
 }
type=Py_NewRef(Py_None);
 }
res=PyObject_SetAttrString(ns, "type", type);
Py_DECREF(type);
if (res<0) {
 goto error;
 }

PyObject*msg=info->msg!=NULL
 ? PyUnicode_FromString(info->msg)
 : Py_NewRef(Py_None);
if (msg==NULL) {
 goto error;
 }
res=PyObject_SetAttrString(ns, "msg", msg);
Py_DECREF(msg);
if (res<0) {
 goto error;
 }

PyObject*formatted=_PyXI_excinfo_format(info);
if (formatted==NULL) {
 goto error;
 }
res=PyObject_SetAttrString(ns, "formatted", formatted);
Py_DECREF(formatted);
if (res<0) {
 goto error;
 }

if (info->errdisplay!=NULL) {
PyObject*tbexc=PyUnicode_FromString(info->errdisplay);
if (tbexc==NULL) {
PyErr_Clear();
 }
else {
res=PyObject_SetAttrString(ns, "errdisplay", tbexc);
Py_DECREF(tbexc);
if (res<0) {
 goto error;
 }
 }
 }

returnns;

error:
Py_DECREF(ns);
returnNULL;
}


int
_PyXI_InitExcInfo(_PyXI_excinfo*info, PyObject*exc)
{
assert(!PyErr_Occurred());
if (exc==NULL||exc==Py_None) {
PyErr_SetString(PyExc_ValueError, "missing exc");
return-1;
 }
constchar*failure;
if (PyExceptionInstance_Check(exc) ||PyExceptionClass_Check(exc)) {
failure=_PyXI_excinfo_InitFromException(info, exc);
 }
else {
failure=_PyXI_excinfo_InitFromObject(info, exc);
 }
if (failure!=NULL) {
PyErr_SetString(PyExc_Exception, failure);
return-1;
 }
return0;
}

PyObject*
_PyXI_FormatExcInfo(_PyXI_excinfo*info)
{
return_PyXI_excinfo_format(info);
}

PyObject*
_PyXI_ExcInfoAsObject(_PyXI_excinfo*info)
{
return_PyXI_excinfo_AsObject(info);
}

void
_PyXI_ClearExcInfo(_PyXI_excinfo*info)
{
_PyXI_excinfo_Clear(info);
}


/***************************/
/* short-term data sharing */
/***************************/

/* error codes */

staticint
_PyXI_ApplyErrorCode(_PyXI_errcodecode, PyInterpreterState*interp)
{
assert(!PyErr_Occurred());
switch (code) {
case_PyXI_ERR_NO_ERROR: // fall through
case_PyXI_ERR_UNCAUGHT_EXCEPTION:
// There is nothing to apply.
#ifdefPy_DEBUG
Py_UNREACHABLE();
#endif
return0;
case_PyXI_ERR_OTHER:
// XXX msg?
PyErr_SetNone(PyExc_InterpreterError);
break;
case_PyXI_ERR_NO_MEMORY:
PyErr_NoMemory();
break;
case_PyXI_ERR_ALREADY_RUNNING:
assert(interp!=NULL);
// In 3.14+ we use _PyErr_SetInterpreterAlreadyRunning().
PyErr_SetString(PyExc_InterpreterError, "interpreter already running");
break;
case_PyXI_ERR_MAIN_NS_FAILURE:
PyErr_SetString(PyExc_InterpreterError,
"failed to get __main__ namespace");
break;
case_PyXI_ERR_APPLY_NS_FAILURE: