#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#include "Python.h"

#include "pycore_code.h" // _PyCode_HAS_EXECUTORS()

#include "pycore_crossinterp.h" // _PyXIData_t

#include "pycore_pyerrors.h" // _PyErr_GetRaisedException()

#include "pycore_interp.h" // _PyInterpreterState_IDIncref()

#include "pycore_modsupport.h" // _PyArg_BadArgument()

#include "pycore_namespace.h" // _PyNamespace_New()

#include "pycore_pybuffer.h" // _PyBuffer_ReleaseInInterpreterAndRawFree()

#include "pycore_pylifecycle.h" // _PyInterpreterConfig_AsDict()

#include "pycore_pystate.h" // _PyInterpreterState_IsRunningMain()

#include "pycore_tuple.h" // _PyTuple_FromPairSteal

#include "marshal.h" // PyMarshal_ReadObjectFromString()

#include "_interpreters_common.h"

#include "clinic/_interpretersmodule.c.h"

#define MODULE_NAME _interpreters

#define MODULE_NAME_STR Py_STRINGIFY(MODULE_NAME)

#define MODINIT_FUNC_NAME RESOLVE_MODINIT_FUNC_NAME(MODULE_NAME)

static PyInterpreterState *

_get_current_interp(void)

{

// PyInterpreterState_Get() aborts if lookup fails, so don't need

// to check the result for NULL.

return PyInterpreterState_Get();

}

#define look_up_interp _PyInterpreterState_LookUpIDObject

static PyObject *

_get_current_module(void)

{

PyObject *name = PyUnicode_FromString(MODULE_NAME_STR);

if (name == NULL) {

return NULL;

}

PyObject *mod = PyImport_GetModule(name);

Py_DECREF(name);

if (mod == NULL) {

return NULL;

}

assert(mod != Py_None);

return mod;

}

static int

is_running_main(PyInterpreterState *interp)

{

if (_PyInterpreterState_IsRunningMain(interp)) {

return 1;

}

// Unlike with the general C-API, we can be confident that someone

// using this module for the main interpreter is doing so through

// the main program. Thus we can make this extra check. This benefits

// applications that embed Python but haven't been updated yet

// to call _PyInterpreterState_SetRunningMain().

if (_Py_IsMainInterpreter(interp)) {

return 1;

}

return 0;

}

static inline int

is_notshareable_raised(PyThreadState *tstate)

{

PyObject *exctype = _PyXIData_GetNotShareableErrorType(tstate);

return _PyErr_ExceptionMatches(tstate, exctype);

}

static void

unwrap_not_shareable(PyThreadState *tstate, _PyXI_failure *failure)

{

if (_PyXI_UnwrapNotShareableError(tstate, failure) < 0) {

_PyErr_Clear(tstate);

}

}

typedef struct {

PyObject base;

Py_buffer *view;

int64_t interpid;

} xibufferview;

static PyObject *

xibufferview_from_buffer(PyTypeObject *cls, Py_buffer *view, int64_t interpid)

{

assert(interpid >= 0);

Py_buffer *copied = PyMem_RawMalloc(sizeof(Py_buffer));

if (copied == NULL) {

return PyErr_NoMemory();

}

/* This steals the view->obj reference */

*copied = *view;

xibufferview *self = PyObject_Malloc(sizeof(xibufferview));

if (self == NULL) {

PyMem_RawFree(copied);

return PyErr_NoMemory();

}

PyObject_Init(&self->base, cls);

*self = (xibufferview){

.base = self->base,

.view = copied,

.interpid = interpid,

};

return (PyObject *)self;

}

static void

xibufferview_dealloc(PyObject *op)

{

xibufferview *self = (xibufferview *)op;

if (self->view != NULL) {

PyInterpreterState *interp =

_PyInterpreterState_LookUpID(self->interpid);

if (interp == NULL) {

/* The interpreter is no longer alive. */

PyErr_Clear();

PyMem_RawFree(self->view);

}

else {

if (_PyBuffer_ReleaseInInterpreterAndRawFree(interp,

self->view) < 0)

{

// XXX Emit a warning?

PyErr_Clear();

}

}

}

PyTypeObject *tp = Py_TYPE(self);

tp->tp_free(self);

/* "Instances of heap-allocated types hold a reference to their type."

// XXX Why don't we implement Py_TPFLAGS_HAVE_GC, e.g. Py_tp_traverse,

// like we do for _abc._abc_data?

Py_DECREF(tp);

}

static int

xibufferview_getbuf(PyObject *op, Py_buffer *view, int flags)

{

/* Only PyMemoryView_FromObject() should ever call this,

xibufferview *self = (xibufferview *)op;

*view = *self->view;

/* This is the workaround mentioned earlier. */

view->obj = op;

// XXX Should we leave it alone?

view->internal = NULL;

return 0;

}

static PyType_Slot XIBufferViewType_slots[] = {

{Py_tp_dealloc, xibufferview_dealloc},

{Py_bf_getbuffer, xibufferview_getbuf},

// We don't bother with Py_bf_releasebuffer since we don't need it.

{0, NULL},

};

static PyType_Spec XIBufferViewType_spec = {

.name = MODULE_NAME_STR ".CrossInterpreterBufferView",

.basicsize = sizeof(xibufferview),

.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |

Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_IMMUTABLETYPE),

.slots = XIBufferViewType_slots,

};

static PyTypeObject * _get_current_xibufferview_type(void);

struct xibuffer {

Py_buffer view;

int used;

};

static PyObject *

_memoryview_from_xid(_PyXIData_t *data)

{

assert(_PyXIData_DATA(data) != NULL);

assert(_PyXIData_OBJ(data) == NULL);

assert(_PyXIData_INTERPID(data) >= 0);

struct xibuffer *view = (struct xibuffer *)_PyXIData_DATA(data);

assert(!view->used);

PyTypeObject *cls = _get_current_xibufferview_type();

if (cls == NULL) {

return NULL;

}

PyObject *obj = xibufferview_from_buffer(

cls, &view->view, _PyXIData_INTERPID(data));

if (obj == NULL) {

return NULL;

}

PyObject *res = PyMemoryView_FromObject(obj);

if (res == NULL) {

Py_DECREF(obj);

return NULL;

}

view->used = 1;

return res;

}

static void

_pybuffer_shared_free(void* data)

{

struct xibuffer *view = (struct xibuffer *)data;

if (!view->used) {

PyBuffer_Release(&view->view);

}

PyMem_RawFree(data);

}

static int

_pybuffer_shared(PyThreadState *tstate, PyObject *obj, _PyXIData_t *data)

{

struct xibuffer *view = PyMem_RawMalloc(sizeof(struct xibuffer));

if (view == NULL) {

PyErr_NoMemory();

return -1;

}

view->used = 0;

/* This will increment the memoryview's export count, which won't get

if (PyObject_GetBuffer(obj, &view->view, PyBUF_FULL_RO) < 0) {

PyMem_RawFree(view);

return -1;

}

/* The view holds a reference to the object, so we don't worry

_PyXIData_Init(data, tstate->interp, view, NULL, _memoryview_from_xid);

data->free = _pybuffer_shared_free;

return 0;

}

static int

register_memoryview_xid(PyObject *mod, PyTypeObject **p_state)

{

// XIBufferView

assert(*p_state == NULL);

PyTypeObject *cls = (PyTypeObject *)PyType_FromModuleAndSpec(

mod, &XIBufferViewType_spec, NULL);

if (cls == NULL) {

return -1;

}

if (PyModule_AddType(mod, cls) < 0) {

Py_DECREF(cls);

return -1;

}

*p_state = cls;

// Register XID for the builtin memoryview type.

if (ensure_xid_class(&PyMemoryView_Type, GETDATA(_pybuffer_shared)) < 0) {

return -1;

}

// We don't ever bother un-registering memoryview.

return 0;

}

typedef struct {

int _notused;

/* heap types */

PyTypeObject *XIBufferViewType;

} module_state;

static inline module_state *

get_module_state(PyObject *mod)

{

assert(mod != NULL);

module_state *state = PyModule_GetState(mod);

assert(state != NULL);

return state;

}

static module_state *

_get_current_module_state(void)

{

PyObject *mod = _get_current_module();

if (mod == NULL) {

mod = PyImport_ImportModule(MODULE_NAME_STR);

if (mod == NULL) {

return NULL;

}

}

module_state *state = get_module_state(mod);

Py_DECREF(mod);

return state;

}

static int

traverse_module_state(module_state *state, visitproc visit, void *arg)

{

/* heap types */

Py_VISIT(state->XIBufferViewType);

return 0;

}

static int

clear_module_state(module_state *state)

{

/* heap types */

Py_CLEAR(state->XIBufferViewType);

return 0;

}

static PyTypeObject *

_get_current_xibufferview_type(void)

{

module_state *state = _get_current_module_state();

if (state == NULL) {

return NULL;

}

return state->XIBufferViewType;

}

static int

init_named_config(PyInterpreterConfig *config, const char *name)

{

if (name == NULL

|| strcmp(name, "") == 0

|| strcmp(name, "default") == 0)

{

name = "isolated";

}

if (strcmp(name, "isolated") == 0) {

*config = (PyInterpreterConfig)_PyInterpreterConfig_INIT;

}

else if (strcmp(name, "legacy") == 0) {

*config = (PyInterpreterConfig)_PyInterpreterConfig_LEGACY_INIT;

}

else if (strcmp(name, "empty") == 0) {

*config = (PyInterpreterConfig){0};

}

else {

PyErr_Format(PyExc_ValueError,

"unsupported config name '%s'", name);

return -1;

}

return 0;

}

static int

config_from_object(PyObject *configobj, PyInterpreterConfig *config)

{

if (configobj == NULL || configobj == Py_None) {

if (init_named_config(config, NULL) < 0) {

return -1;

}

}

else if (PyUnicode_Check(configobj)) {

const char *utf8name = PyUnicode_AsUTF8(configobj);

if (utf8name == NULL) {

return -1;

}

if (init_named_config(config, utf8name) < 0) {

return -1;

}

}

else {

PyObject *dict = PyObject_GetAttrString(configobj, "__dict__");

if (dict == NULL) {

PyErr_Format(PyExc_TypeError, "bad config %R", configobj);

return -1;

}

int res = _PyInterpreterConfig_InitFromDict(config, dict);

Py_DECREF(dict);

if (res < 0) {

return -1;

}

}

return 0;

}

struct interp_call {

};

static void

_interp_call_clear(struct interp_call *call)

{

if (call->func != NULL) {

_PyXIData_Clear(NULL, call->func);

}

if (call->args != NULL) {

_PyXIData_Clear(NULL, call->args);

}

if (call->kwargs != NULL) {

_PyXIData_Clear(NULL, call->kwargs);

}

*call = (struct interp_call){0};

}

static int

_interp_call_pack(PyThreadState *tstate, struct interp_call *call,

PyObject *func, PyObject *args, PyObject *kwargs)

{

xidata_fallback_t fallback = _PyXIDATA_FULL_FALLBACK;

assert(call->func == NULL);

assert(call->args == NULL);

assert(call->kwargs == NULL);

// Handle the func.

if (!PyCallable_Check(func)) {

_PyErr_Format(tstate, PyExc_TypeError,

"expected a callable, got %R", func);

return -1;

}

if (_PyFunction_GetXIData(tstate, func, &call->_preallocated.func) < 0) {

PyObject *exc = _PyErr_GetRaisedException(tstate);

if (_PyPickle_GetXIData(tstate, func, &call->_preallocated.func) < 0) {

_PyErr_SetRaisedException(tstate, exc);

return -1;

}

Py_DECREF(exc);

}

call->func = &call->_preallocated.func;

// Handle the args.

if (args == NULL || args == Py_None) {

// Leave it empty.

}

else {

assert(PyTuple_Check(args));

if (PyTuple_GET_SIZE(args) > 0) {

if (_PyObject_GetXIData(

tstate, args, fallback, &call->_preallocated.args) < 0)

{

_interp_call_clear(call);

return -1;

}

call->args = &call->_preallocated.args;

}

}

// Handle the kwargs.

if (kwargs == NULL || kwargs == Py_None) {

// Leave it empty.

}

else {

assert(PyDict_Check(kwargs));

if (PyDict_GET_SIZE(kwargs) > 0) {

if (_PyObject_GetXIData(

tstate, kwargs, fallback, &call->_preallocated.kwargs) < 0)

{

_interp_call_clear(call);

return -1;

}

call->kwargs = &call->_preallocated.kwargs;

}

}

return 0;

}

static void

wrap_notshareable(PyThreadState *tstate, const char *label)

{

if (!is_notshareable_raised(tstate)) {

return;

}

assert(label != NULL && strlen(label) > 0);

PyObject *cause = _PyErr_GetRaisedException(tstate);

_PyXIData_FormatNotShareableError(tstate, "%s not shareable", label);

PyObject *exc = _PyErr_GetRaisedException(tstate);

PyException_SetCause(exc, cause);

_PyErr_SetRaisedException(tstate, exc);

}

static int

_interp_call_unpack(struct interp_call *call,

PyObject **p_func, PyObject **p_args, PyObject **p_kwargs)

{

PyThreadState *tstate = PyThreadState_Get();

// Unpack the func.

PyObject *func = _PyXIData_NewObject(call->func);

if (func == NULL) {

wrap_notshareable(tstate, "func");

return -1;

}

// Unpack the args.

PyObject *args;

if (call->args == NULL) {

args = PyTuple_New(0);

if (args == NULL) {

Py_DECREF(func);

return -1;

}

}

else {

args = _PyXIData_NewObject(call->args);

if (args == NULL) {

wrap_notshareable(tstate, "args");

Py_DECREF(func);

return -1;

}

assert(PyTuple_Check(args));

}

// Unpack the kwargs.

PyObject *kwargs = NULL;

if (call->kwargs != NULL) {

kwargs = _PyXIData_NewObject(call->kwargs);

if (kwargs == NULL) {

wrap_notshareable(tstate, "kwargs");

Py_DECREF(func);

Py_DECREF(args);

return -1;

}

assert(PyDict_Check(kwargs));

}

*p_func = func;

*p_args = args;

*p_kwargs = kwargs;

return 0;

}

static int

_make_call(struct interp_call *call,

PyObject **p_result, _PyXI_failure *failure)

{

assert(call != NULL && call->func != NULL);

PyThreadState *tstate = _PyThreadState_GET();

// Get the func and args.

PyObject *func = NULL, *args = NULL, *kwargs = NULL;

if (_interp_call_unpack(call, &func, &args, &kwargs) < 0) {

assert(func == NULL);

assert(args == NULL);

assert(kwargs == NULL);

_PyXI_InitFailure(failure, _PyXI_ERR_OTHER, NULL);

unwrap_not_shareable(tstate, failure);

return -1;

}

assert(!_PyErr_Occurred(tstate));

// Make the call.

PyObject *resobj = PyObject_Call(func, args, kwargs);

Py_DECREF(func);

Py_XDECREF(args);

Py_XDECREF(kwargs);

if (resobj == NULL) {

return -1;

}

*p_result = resobj;

return 0;

}

static int

_run_script(_PyXIData_t *script, PyObject *ns, _PyXI_failure *failure)

{

PyObject *code = _PyXIData_NewObject(script);

if (code == NULL) {

_PyXI_InitFailure(failure, _PyXI_ERR_NOT_SHAREABLE, NULL);

return -1;

}

PyObject *result = PyEval_EvalCode(code, ns, ns);

Py_DECREF(code);

if (result == NULL) {

_PyXI_InitFailure(failure, _PyXI_ERR_UNCAUGHT_EXCEPTION, NULL);

return -1;

}

assert(result == Py_None);

Py_DECREF(result); // We throw away the result.

return 0;

}

struct run_result {

PyObject *result;

PyObject *excinfo;

};

static void

_run_result_clear(struct run_result *runres)

{

Py_CLEAR(runres->result);

Py_CLEAR(runres->excinfo);

}

static int

_run_in_interpreter(PyThreadState *tstate, PyInterpreterState *interp,

_PyXIData_t *script, struct interp_call *call,

PyObject *shareables, struct run_result *runres)

{

assert(!_PyErr_Occurred(tstate));

int res = -1;

_PyXI_failure *failure = _PyXI_NewFailure();

if (failure == NULL) {

return -1;

}

_PyXI_session *session = _PyXI_NewSession();

if (session == NULL) {

_PyXI_FreeFailure(failure);

return -1;

}

_PyXI_session_result result = {0};

// Prep and switch interpreters.

if (_PyXI_Enter(session, interp, shareables, &result) < 0) {

// If an error occurred at this step, it means that interp

// was not prepared and switched.

_PyXI_FreeSession(session);

_PyXI_FreeFailure(failure);

assert(result.excinfo == NULL);

return -1;

}

// Run in the interpreter.

if (script != NULL) {

assert(call == NULL);

PyObject *mainns = _PyXI_GetMainNamespace(session, failure);

if (mainns == NULL) {

goto finally;

}

res = _run_script(script, mainns, failure);

}

else {

assert(call != NULL);

PyObject *resobj;

res = _make_call(call, &resobj, failure);

if (res == 0) {

res = _PyXI_Preserve(session, "resobj", resobj, failure);

Py_DECREF(resobj);

if (res < 0) {

goto finally;

}

}

}

finally:

// Clean up and switch back.

(void)res;

int exitres = _PyXI_Exit(session, failure, &result);

assert(res == 0 || exitres != 0);

_PyXI_FreeSession(session);

_PyXI_FreeFailure(failure);

res = exitres;

if (_PyErr_Occurred(tstate)) {

// It's a directly propagated exception.

assert(res < 0);

}

else if (res < 0) {

assert(result.excinfo != NULL);

runres->excinfo = Py_NewRef(result.excinfo);

res = -1;

}

else {

assert(result.excinfo == NULL);

runres->result = _PyXI_GetPreserved(&result, "resobj");

if (_PyErr_Occurred(tstate)) {

res = -1;

}

}

_PyXI_ClearResult(&result);

return res;

}

static long

get_whence(PyInterpreterState *interp)

{

return _PyInterpreterState_GetWhence(interp);

}

static PyInterpreterState *

resolve_interp(PyObject *idobj, int restricted, int reqready, const char *op)

{

PyInterpreterState *interp;

if (idobj == NULL) {

interp = PyInterpreterState_Get();

}

else {

interp = look_up_interp(idobj);

if (interp == NULL) {

return NULL;

}

}

if (reqready && !_PyInterpreterState_IsReady(interp)) {

if (idobj == NULL) {

PyErr_Format(PyExc_InterpreterError,

"cannot %s current interpreter (not ready)", op);

}

else {

PyErr_Format(PyExc_InterpreterError,

"cannot %s interpreter %R (not ready)", op, idobj);

}

return NULL;

}

if (restricted && get_whence(interp) != _PyInterpreterState_WHENCE_STDLIB) {

if (idobj == NULL) {

PyErr_Format(PyExc_InterpreterError,

"cannot %s unrecognized current interpreter", op);

}

else {

PyErr_Format(PyExc_InterpreterError,

"cannot %s unrecognized interpreter %R", op, idobj);

}

return NULL;

}

return interp;

}

static PyObject *

get_summary(PyInterpreterState *interp)

{

PyObject *idobj = _PyInterpreterState_GetIDObject(interp);

if (idobj == NULL) {

return NULL;

}

PyObject *whenceobj = PyLong_FromLong(

get_whence(interp));

if (whenceobj == NULL) {

Py_DECREF(idobj);

return NULL;

}

return _PyTuple_FromPairSteal(idobj, whenceobj);

}

static PyObject *

interp_new_config(PyObject *self, PyObject *args, PyObject *kwds)

{

const char *name = NULL;

if (!PyArg_ParseTuple(args, "|s:" MODULE_NAME_STR ".new_config", &name))

{

return NULL;

}

PyObject *overrides = kwds;

PyInterpreterConfig config;

if (init_named_config(&config, name) < 0) {

return NULL;

}

if (overrides != NULL && PyDict_GET_SIZE(overrides) > 0) {

if (_PyInterpreterConfig_UpdateFromDict(&config, overrides) < 0) {

return NULL;

}

}

PyObject *dict = _PyInterpreterConfig_AsDict(&config);

if (dict == NULL) {

return NULL;

}

PyObject *configobj = _PyNamespace_New(dict);

Py_DECREF(dict);

return configobj;

}

PyDoc_STRVAR(new_config_doc,

overriding the initial values.");

static PyObject *

_interpreters_create_impl(PyObject *module, PyObject *configobj, int reqrefs)

{

PyInterpreterConfig config;

if (config_from_object(configobj, &config) < 0) {

return NULL;

}

long whence = _PyInterpreterState_WHENCE_STDLIB;

PyInterpreterState *interp = \

_PyXI_NewInterpreter(&config, &whence, NULL, NULL);

if (interp == NULL) {

// XXX Move the chained exception to interpreters.create()?

PyObject *exc = PyErr_GetRaisedException();

assert(exc != NULL);

PyErr_SetString(PyExc_InterpreterError, "interpreter creation failed");

_PyErr_ChainExceptions1(exc);

return NULL;

}

assert(_PyInterpreterState_IsReady(interp));

PyObject *idobj = _PyInterpreterState_GetIDObject(interp);

if (idobj == NULL) {

_PyXI_EndInterpreter(interp, NULL, NULL);

return NULL;

}

if (reqrefs) {

// Decref to 0 will destroy the interpreter.

_PyInterpreterState_RequireIDRef(interp, 1);

}

return idobj;

}

static PyObject *

_interpreters_destroy_impl(PyObject *module, PyObject *id, int restricted)

{

// Look up the interpreter.

int reqready = 0;

PyInterpreterState *interp = \

resolve_interp(id, restricted, reqready, "destroy");

if (interp == NULL) {

return NULL;

}

// Ensure we don't try to destroy the current interpreter.

PyInterpreterState *current = _get_current_interp();

if (current == NULL) {

return NULL;

}

if (interp == current) {

PyErr_SetString(PyExc_InterpreterError,

"cannot destroy the current interpreter");

return NULL;

}

// Ensure the interpreter isn't running.

/* XXX We *could* support destroying a running interpreter but

if (is_running_main(interp)) {

PyErr_Format(PyExc_InterpreterError, "interpreter running");

return NULL;

}

// Destroy the interpreter.

_PyXI_EndInterpreter(interp, NULL, NULL);

Py_RETURN_NONE;

}

static PyObject *

_interpreters_list_all_impl(PyObject *module, int reqready)

{

PyObject *ids = PyList_New(0);

if (ids == NULL) {

return NULL;

}

PyInterpreterState *interp = PyInterpreterState_Head();

while (interp != NULL) {

if (!reqready || _PyInterpreterState_IsReady(interp)) {

PyObject *item = get_summary(interp);

if (item == NULL) {

Py_DECREF(ids);

return NULL;

}

// insert at front of list

int res = PyList_Insert(ids, 0, item);

Py_DECREF(item);

if (res < 0) {

Py_DECREF(ids);

return NULL;

}

}

interp = PyInterpreterState_Next(interp);

}

return ids;

}