#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#include "Python.h"

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

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

#include "pycore_runtime_init.h" // _Py_ID()

#include "pycore_moduleobject.h" // _PyModule_GetState()

#include "structmember.h" // PyMemberDef

#include <stddef.h> // offsetof()

typedef struct {

PyTypeObject *FutureIterType;

PyTypeObject *TaskStepMethWrapper_Type;

PyTypeObject *FutureType;

PyTypeObject *TaskType;

PyObject *asyncio_mod;

PyObject *context_kwname;

/* Dictionary containing tasks that are currently active in

PyObject *current_tasks;

/* WeakSet containing all alive tasks. */

PyObject *all_tasks;

/* An isinstance type cache for the 'is_coroutine()' function. */

PyObject *iscoroutine_typecache;

/* Imports from asyncio.events. */

PyObject *asyncio_get_event_loop_policy;

/* Imports from asyncio.base_futures. */

PyObject *asyncio_future_repr_func;

/* Imports from asyncio.exceptions. */

PyObject *asyncio_CancelledError;

PyObject *asyncio_InvalidStateError;

/* Imports from asyncio.base_tasks. */

PyObject *asyncio_task_get_stack_func;

PyObject *asyncio_task_print_stack_func;

PyObject *asyncio_task_repr_func;

/* Imports from asyncio.coroutines. */

PyObject *asyncio_iscoroutine_func;

/* Imports from traceback. */

PyObject *traceback_extract_stack;

PyObject *cached_running_loop; // Borrowed reference

volatile uint64_t cached_running_loop_tsid;

/* Counter for autogenerated Task names */

uint64_t task_name_counter;

} asyncio_state;

static inline asyncio_state *

get_asyncio_state(PyObject *mod)

{

asyncio_state *state = _PyModule_GetState(mod);

assert(state != NULL);

return state;

}

static inline asyncio_state *

get_asyncio_state_by_cls(PyTypeObject *cls)

{

asyncio_state *state = (asyncio_state *)_PyType_GetModuleState(cls);

assert(state != NULL);

return state;

}

static struct PyModuleDef _asynciomodule;

static inline asyncio_state *

get_asyncio_state_by_def(PyObject *self)

{

PyTypeObject *tp = Py_TYPE(self);

PyObject *mod = PyType_GetModuleByDef(tp, &_asynciomodule);

assert(mod != NULL);

return get_asyncio_state(mod);

}

typedef enum {

STATE_PENDING,

STATE_CANCELLED,

STATE_FINISHED

} fut_state;

#define FutureObj_HEAD(prefix) \

PyObject_HEAD \

PyObject *prefix##_loop; \

PyObject *prefix##_callback0; \

PyObject *prefix##_context0; \

PyObject *prefix##_callbacks; \

PyObject *prefix##_exception; \

PyObject *prefix##_exception_tb; \

PyObject *prefix##_result; \

PyObject *prefix##_source_tb; \

PyObject *prefix##_cancel_msg; \

fut_state prefix##_state; \

int prefix##_log_tb; \

int prefix##_blocking; \

PyObject *dict; \

PyObject *prefix##_weakreflist; \

PyObject *prefix##_cancelled_exc;

typedef struct {

FutureObj_HEAD(fut)

} FutureObj;

typedef struct {

FutureObj_HEAD(task)

PyObject *task_fut_waiter;

PyObject *task_coro;

PyObject *task_name;

PyObject *task_context;

int task_must_cancel;

int task_log_destroy_pending;

int task_num_cancels_requested;

} TaskObj;

typedef struct {

PyObject_HEAD

TaskObj *sw_task;

PyObject *sw_arg;

} TaskStepMethWrapper;

#define Future_CheckExact(state, obj) Py_IS_TYPE(obj, state->FutureType)

#define Task_CheckExact(state, obj) Py_IS_TYPE(obj, state->TaskType)

#define Future_Check(state, obj) PyObject_TypeCheck(obj, state->FutureType)

#define Task_Check(state, obj) PyObject_TypeCheck(obj, state->TaskType)

#include "clinic/_asynciomodule.c.h"

static PyObject * future_new_iter(PyObject *);

static int

_is_coroutine(asyncio_state *state, PyObject *coro)

{

/* 'coro' is not a native coroutine, call asyncio.iscoroutine()

PyObject *res = PyObject_CallOneArg(state->asyncio_iscoroutine_func, coro);

if (res == NULL) {

return -1;

}

int is_res_true = PyObject_IsTrue(res);

Py_DECREF(res);

if (is_res_true <= 0) {

return is_res_true;

}

if (PySet_GET_SIZE(state->iscoroutine_typecache) < 100) {

/* Just in case we don't want to cache more than 100

if (PySet_Add(state->iscoroutine_typecache, (PyObject*) Py_TYPE(coro))) {

return -1;

}

}

return 1;

}

static inline int

is_coroutine(asyncio_state *state, PyObject *coro)

{

if (PyCoro_CheckExact(coro)) {

return 1;

}

/* Check if `type(coro)` is in the cache.

int has_it = PySet_Contains(

state->iscoroutine_typecache, (PyObject*) Py_TYPE(coro));

if (has_it == 0) {

/* type(coro) is not in iscoroutine_typecache */

return _is_coroutine(state, coro);

}

/* either an error has occurred or

return has_it;

}

static PyObject *

get_future_loop(asyncio_state *state, PyObject *fut)

{

/* Implementation of `asyncio.futures._get_loop` */

PyObject *getloop;

if (Future_CheckExact(state, fut) || Task_CheckExact(state, fut)) {

PyObject *loop = ((FutureObj *)fut)->fut_loop;

return Py_NewRef(loop);

}

if (_PyObject_LookupAttr(fut, &_Py_ID(get_loop), &getloop) < 0) {

return NULL;

}

if (getloop != NULL) {

PyObject *res = PyObject_CallNoArgs(getloop);

Py_DECREF(getloop);

return res;

}

return PyObject_GetAttr(fut, &_Py_ID(_loop));

}

static int

get_running_loop(asyncio_state *state, PyObject **loop)

{

PyObject *rl;

PyThreadState *ts = _PyThreadState_GET();

uint64_t ts_id = PyThreadState_GetID(ts);

if (state->cached_running_loop_tsid == ts_id &&

state->cached_running_loop != NULL)

{

// Fast path, check the cache.

rl = state->cached_running_loop;

}

else {

PyObject *ts_dict = _PyThreadState_GetDict(ts); // borrowed

if (ts_dict == NULL) {

goto not_found;

}

rl = PyDict_GetItemWithError(

ts_dict, &_Py_ID(__asyncio_running_event_loop__)); // borrowed

if (rl == NULL) {

if (PyErr_Occurred()) {

goto error;

}

else {

goto not_found;

}

}

state->cached_running_loop = rl;

state->cached_running_loop_tsid = ts_id;

}

if (rl == Py_None) {

goto not_found;

}

*loop = Py_NewRef(rl);

return 0;

not_found:

*loop = NULL;

return 0;

error:

*loop = NULL;

return -1;

}

static int

set_running_loop(asyncio_state *state, PyObject *loop)

{

PyObject *ts_dict = NULL;

PyThreadState *tstate = _PyThreadState_GET();

if (tstate != NULL) {

ts_dict = _PyThreadState_GetDict(tstate); // borrowed

}

if (ts_dict == NULL) {

PyErr_SetString(

PyExc_RuntimeError, "thread-local storage is not available");

return -1;

}

if (PyDict_SetItem(

ts_dict, &_Py_ID(__asyncio_running_event_loop__), loop) < 0)

{

return -1;

}

state->cached_running_loop = loop; // borrowed, kept alive by ts_dict

state->cached_running_loop_tsid = PyThreadState_GetID(tstate);

return 0;

}

static PyObject *

get_event_loop(asyncio_state *state)

{

PyObject *loop;

PyObject *policy;

if (get_running_loop(state, &loop)) {

return NULL;

}

if (loop != NULL) {

return loop;

}

policy = PyObject_CallNoArgs(state->asyncio_get_event_loop_policy);

if (policy == NULL) {

return NULL;

}

loop = PyObject_CallMethodNoArgs(policy, &_Py_ID(get_event_loop));

Py_DECREF(policy);

return loop;

}

static int

call_soon(asyncio_state *state, PyObject *loop, PyObject *func, PyObject *arg,

PyObject *ctx)

{

PyObject *handle;

if (ctx == NULL) {

PyObject *stack[] = {loop, func, arg};

size_t nargsf = 3 | PY_VECTORCALL_ARGUMENTS_OFFSET;

handle = PyObject_VectorcallMethod(&_Py_ID(call_soon), stack, nargsf, NULL);

}

else {

/* All refs in 'stack' are borrowed. */

PyObject *stack[4];

size_t nargs = 2;

stack[0] = loop;

stack[1] = func;

if (arg != NULL) {

stack[2] = arg;

nargs++;

}

stack[nargs] = (PyObject *)ctx;

size_t nargsf = nargs | PY_VECTORCALL_ARGUMENTS_OFFSET;

handle = PyObject_VectorcallMethod(&_Py_ID(call_soon), stack, nargsf,

state->context_kwname);

}

if (handle == NULL) {

return -1;

}

Py_DECREF(handle);

return 0;

}

static inline int

future_is_alive(FutureObj *fut)

{

return fut->fut_loop != NULL;

}

static inline int

future_ensure_alive(FutureObj *fut)

{

if (!future_is_alive(fut)) {

PyErr_SetString(PyExc_RuntimeError,

"Future object is not initialized.");

return -1;

}

return 0;

}

#define ENSURE_FUTURE_ALIVE(state, fut) \

do { \

assert(Future_Check(state, fut) || Task_Check(state, fut)); \

(void)state; \

if (future_ensure_alive((FutureObj*)fut)) { \

return NULL; \

} \

} while(0);

static int

future_schedule_callbacks(asyncio_state *state, FutureObj *fut)

{

Py_ssize_t len;

Py_ssize_t i;

if (fut->fut_callback0 != NULL) {

/* There's a 1st callback */

int ret = call_soon(state,

fut->fut_loop, fut->fut_callback0,

(PyObject *)fut, fut->fut_context0);

Py_CLEAR(fut->fut_callback0);

Py_CLEAR(fut->fut_context0);

if (ret) {

/* If an error occurs in pure-Python implementation,

Py_CLEAR(fut->fut_callbacks);

return ret;

}

/* we called the first callback, now try calling

}

if (fut->fut_callbacks == NULL) {

/* No more callbacks, return. */

return 0;

}

len = PyList_GET_SIZE(fut->fut_callbacks);

if (len == 0) {

/* The list of callbacks was empty; clear it and return. */

Py_CLEAR(fut->fut_callbacks);

return 0;

}

for (i = 0; i < len; i++) {

PyObject *cb_tup = PyList_GET_ITEM(fut->fut_callbacks, i);

PyObject *cb = PyTuple_GET_ITEM(cb_tup, 0);

PyObject *ctx = PyTuple_GET_ITEM(cb_tup, 1);

if (call_soon(state, fut->fut_loop, cb, (PyObject *)fut, ctx)) {

/* If an error occurs in pure-Python implementation,

Py_CLEAR(fut->fut_callbacks);

return -1;

}

}

Py_CLEAR(fut->fut_callbacks);

return 0;

}

static int

future_init(FutureObj *fut, PyObject *loop)

{

PyObject *res;

int is_true;

// Same to FutureObj_clear() but not clearing fut->dict

Py_CLEAR(fut->fut_loop);

Py_CLEAR(fut->fut_callback0);

Py_CLEAR(fut->fut_context0);

Py_CLEAR(fut->fut_callbacks);

Py_CLEAR(fut->fut_result);

Py_CLEAR(fut->fut_exception);

Py_CLEAR(fut->fut_exception_tb);

Py_CLEAR(fut->fut_source_tb);

Py_CLEAR(fut->fut_cancel_msg);

Py_CLEAR(fut->fut_cancelled_exc);

fut->fut_state = STATE_PENDING;

fut->fut_log_tb = 0;

fut->fut_blocking = 0;

if (loop == Py_None) {

asyncio_state *state = get_asyncio_state_by_def((PyObject *)fut);

loop = get_event_loop(state);

if (loop == NULL) {

return -1;

}

}

else {

Py_INCREF(loop);

}

fut->fut_loop = loop;

res = PyObject_CallMethodNoArgs(fut->fut_loop, &_Py_ID(get_debug));

if (res == NULL) {

return -1;

}

is_true = PyObject_IsTrue(res);

Py_DECREF(res);

if (is_true < 0) {

return -1;

}

if (is_true && !_Py_IsFinalizing()) {

/* Only try to capture the traceback if the interpreter is not being

asyncio_state *state = get_asyncio_state_by_def((PyObject *)fut);

fut->fut_source_tb = PyObject_CallNoArgs(state->traceback_extract_stack);

if (fut->fut_source_tb == NULL) {

return -1;

}

}

return 0;

}

static PyObject *

future_set_result(asyncio_state *state, FutureObj *fut, PyObject *res)

{

if (future_ensure_alive(fut)) {

return NULL;

}

if (fut->fut_state != STATE_PENDING) {

PyErr_SetString(state->asyncio_InvalidStateError, "invalid state");

return NULL;

}

assert(!fut->fut_result);

fut->fut_result = Py_NewRef(res);

fut->fut_state = STATE_FINISHED;

if (future_schedule_callbacks(state, fut) == -1) {

return NULL;

}

Py_RETURN_NONE;

}

static PyObject *

future_set_exception(asyncio_state *state, FutureObj *fut, PyObject *exc)

{

PyObject *exc_val = NULL;

if (fut->fut_state != STATE_PENDING) {

PyErr_SetString(state->asyncio_InvalidStateError, "invalid state");

return NULL;

}

if (PyExceptionClass_Check(exc)) {

exc_val = PyObject_CallNoArgs(exc);

if (exc_val == NULL) {

return NULL;

}

if (fut->fut_state != STATE_PENDING) {

Py_DECREF(exc_val);

PyErr_SetString(state->asyncio_InvalidStateError, "invalid state");

return NULL;

}

}

else {

exc_val = Py_NewRef(exc);

}

if (!PyExceptionInstance_Check(exc_val)) {

Py_DECREF(exc_val);

PyErr_SetString(PyExc_TypeError, "invalid exception object");

return NULL;

}

if (Py_IS_TYPE(exc_val, (PyTypeObject *)PyExc_StopIteration)) {

Py_DECREF(exc_val);

PyErr_SetString(PyExc_TypeError,

"StopIteration interacts badly with generators "

"and cannot be raised into a Future");

return NULL;

}

assert(!fut->fut_exception);

assert(!fut->fut_exception_tb);

fut->fut_exception = exc_val;

fut->fut_exception_tb = PyException_GetTraceback(exc_val);

fut->fut_state = STATE_FINISHED;

if (future_schedule_callbacks(state, fut) == -1) {

return NULL;

}

fut->fut_log_tb = 1;

Py_RETURN_NONE;

}

static PyObject *

create_cancelled_error(asyncio_state *state, FutureObj *fut)

{

PyObject *exc;

if (fut->fut_cancelled_exc != NULL) {

/* transfer ownership */

exc = fut->fut_cancelled_exc;

fut->fut_cancelled_exc = NULL;

return exc;

}

PyObject *msg = fut->fut_cancel_msg;

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

exc = PyObject_CallNoArgs(state->asyncio_CancelledError);

} else {

exc = PyObject_CallOneArg(state->asyncio_CancelledError, msg);

}

return exc;

}

static void

future_set_cancelled_error(asyncio_state *state, FutureObj *fut)

{

PyObject *exc = create_cancelled_error(state, fut);

if (exc == NULL) {

return;

}

PyErr_SetObject(state->asyncio_CancelledError, exc);

Py_DECREF(exc);

}

static int

future_get_result(asyncio_state *state, FutureObj *fut, PyObject **result)

{

if (fut->fut_state == STATE_CANCELLED) {

future_set_cancelled_error(state, fut);

return -1;

}

if (fut->fut_state != STATE_FINISHED) {

PyErr_SetString(state->asyncio_InvalidStateError,

"Result is not set.");

return -1;

}

fut->fut_log_tb = 0;

if (fut->fut_exception != NULL) {

PyObject *tb = fut->fut_exception_tb;

if (tb == NULL) {

tb = Py_None;

}

if (PyException_SetTraceback(fut->fut_exception, tb) < 0) {

return -1;

}

*result = Py_NewRef(fut->fut_exception);

Py_CLEAR(fut->fut_exception_tb);

return 1;

}

*result = Py_NewRef(fut->fut_result);

return 0;

}

static PyObject *

future_add_done_callback(asyncio_state *state, FutureObj *fut, PyObject *arg,

PyObject *ctx)

{

if (!future_is_alive(fut)) {

PyErr_SetString(PyExc_RuntimeError, "uninitialized Future object");

return NULL;

}

if (fut->fut_state != STATE_PENDING) {

/* The future is done/cancelled, so schedule the callback

if (call_soon(state, fut->fut_loop, arg, (PyObject*) fut, ctx)) {

return NULL;

}

}

else {

/* The future is pending, add a callback.

if (fut->fut_callbacks == NULL && fut->fut_callback0 == NULL) {

fut->fut_callback0 = Py_NewRef(arg);

fut->fut_context0 = Py_NewRef(ctx);

}

else {

PyObject *tup = PyTuple_New(2);

if (tup == NULL) {

return NULL;

}

Py_INCREF(arg);

PyTuple_SET_ITEM(tup, 0, arg);

Py_INCREF(ctx);

PyTuple_SET_ITEM(tup, 1, (PyObject *)ctx);

if (fut->fut_callbacks != NULL) {

int err = PyList_Append(fut->fut_callbacks, tup);

if (err) {

Py_DECREF(tup);

return NULL;

}

Py_DECREF(tup);

}

else {

fut->fut_callbacks = PyList_New(1);

if (fut->fut_callbacks == NULL) {

Py_DECREF(tup);

return NULL;

}

PyList_SET_ITEM(fut->fut_callbacks, 0, tup); /* borrow */

}

}

}

Py_RETURN_NONE;

}

static PyObject *

future_cancel(asyncio_state *state, FutureObj *fut, PyObject *msg)

{

fut->fut_log_tb = 0;

if (fut->fut_state != STATE_PENDING) {

Py_RETURN_FALSE;

}

fut->fut_state = STATE_CANCELLED;

Py_XINCREF(msg);

Py_XSETREF(fut->fut_cancel_msg, msg);

if (future_schedule_callbacks(state, fut) == -1) {

return NULL;

}

Py_RETURN_TRUE;

}

static int

_asyncio_Future___init___impl(FutureObj *self, PyObject *loop)

{

return future_init(self, loop);

}

static int

FutureObj_clear(FutureObj *fut)

{

Py_CLEAR(fut->fut_loop);

Py_CLEAR(fut->fut_callback0);

Py_CLEAR(fut->fut_context0);

Py_CLEAR(fut->fut_callbacks);

Py_CLEAR(fut->fut_result);

Py_CLEAR(fut->fut_exception);

Py_CLEAR(fut->fut_exception_tb);

Py_CLEAR(fut->fut_source_tb);

Py_CLEAR(fut->fut_cancel_msg);

Py_CLEAR(fut->fut_cancelled_exc);

Py_CLEAR(fut->dict);

return 0;

}

static int

FutureObj_traverse(FutureObj *fut, visitproc visit, void *arg)

{

Py_VISIT(Py_TYPE(fut));

Py_VISIT(fut->fut_loop);

Py_VISIT(fut->fut_callback0);

Py_VISIT(fut->fut_context0);

Py_VISIT(fut->fut_callbacks);

Py_VISIT(fut->fut_result);

Py_VISIT(fut->fut_exception);

Py_VISIT(fut->fut_exception_tb);

Py_VISIT(fut->fut_source_tb);

Py_VISIT(fut->fut_cancel_msg);

Py_VISIT(fut->fut_cancelled_exc);

Py_VISIT(fut->dict);

return 0;

}

static PyObject *

_asyncio_Future_result_impl(FutureObj *self)

{

asyncio_state *state = get_asyncio_state_by_def((PyObject *)self);

PyObject *result;

if (!future_is_alive(self)) {

PyErr_SetString(state->asyncio_InvalidStateError,

"Future object is not initialized.");

return NULL;

}

int res = future_get_result(state, self, &result);

if (res == -1) {

return NULL;

}

if (res == 0) {

return result;

}

assert(res == 1);

PyErr_SetObject(PyExceptionInstance_Class(result), result);

Py_DECREF(result);

return NULL;

}

static PyObject *

_asyncio_Future_exception_impl(FutureObj *self, PyTypeObject *cls)

{

if (!future_is_alive(self)) {

asyncio_state *state = get_asyncio_state_by_cls(cls);

PyErr_SetString(state->asyncio_InvalidStateError,

"Future object is not initialized.");

return NULL;

}

if (self->fut_state == STATE_CANCELLED) {

asyncio_state *state = get_asyncio_state_by_cls(cls);

future_set_cancelled_error(state, self);

return NULL;

}

if (self->fut_state != STATE_FINISHED) {

asyncio_state *state = get_asyncio_state_by_cls(cls);

PyErr_SetString(state->asyncio_InvalidStateError,

"Exception is not set.");

return NULL;

}

if (self->fut_exception != NULL) {

self->fut_log_tb = 0;

return Py_NewRef(self->fut_exception);

}

Py_RETURN_NONE;

}

static PyObject *

_asyncio_Future_set_result_impl(FutureObj *self, PyTypeObject *cls,

PyObject *result)

{

asyncio_state *state = get_asyncio_state_by_cls(cls);

ENSURE_FUTURE_ALIVE(state, self)

return future_set_result(state, self, result);

}

static PyObject *

_asyncio_Future_set_exception_impl(FutureObj *self, PyTypeObject *cls,

PyObject *exception)

{

asyncio_state *state = get_asyncio_state_by_cls(cls);

ENSURE_FUTURE_ALIVE(state, self)

return future_set_exception(state, self, exception);

}

static PyObject *

_asyncio_Future_add_done_callback_impl(FutureObj *self, PyTypeObject *cls,

PyObject *fn, PyObject *context)

{

asyncio_state *state = get_asyncio_state_by_cls(cls);

if (context == NULL) {

context = PyContext_CopyCurrent();

if (context == NULL) {

return NULL;

}

PyObject *res = future_add_done_callback(state, self, fn, context);

Py_DECREF(context);

return res;

}

return future_add_done_callback(state, self, fn, context);

}