#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#include "Python.h"

#include "pycore_freelist.h" // _Py_FREELIST_POP()

#include "pycore_genobject.h"

#include "pycore_llist.h" // struct llist_node

#include "pycore_list.h" // _PyList_AppendTakeRef()

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

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

#include "pycore_object.h" // _PyObject_SetMaybeWeakref

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

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

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

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

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; \

PyObject *prefix##_cancelled_exc; \

PyObject *prefix##_awaited_by; \

fut_state prefix##_state; \

/* Used by profilers to make traversing the stack from an external \

process faster. */ \

char prefix##_is_task; \

char prefix##_awaited_by_is_set; \

/* These bitfields need to be at the end of the struct \

*/ \

unsigned prefix##_log_tb: 1; \

unsigned prefix##_blocking: 1; \

typedef struct {

FutureObj_HEAD(fut)

} FutureObj;

typedef struct TaskObj {

} 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) \

(Future_CheckExact(state, obj) \

|| PyObject_TypeCheck(obj, state->FutureType))

#define Task_Check(state, obj) \

(Task_CheckExact(state, obj) \

|| PyObject_TypeCheck(obj, state->TaskType))

#define TaskOrFuture_Check(state, obj) \

(Task_CheckExact(state, obj) \

|| Future_CheckExact(state, obj) \

|| PyObject_TypeCheck(obj, state->FutureType) \

|| PyObject_TypeCheck(obj, state->TaskType))

typedef struct _Py_AsyncioModuleDebugOffsets {

} Py_AsyncioModuleDebugOffsets;

GENERATE_DEBUG_SECTION(AsyncioDebug, Py_AsyncioModuleDebugOffsets _AsyncioDebug)

= {.asyncio_task_object = {

.size = sizeof(TaskObj),

.task_name = offsetof(TaskObj, task_name),

.task_awaited_by = offsetof(TaskObj, task_awaited_by),

.task_is_task = offsetof(TaskObj, task_is_task),

.task_awaited_by_is_set = offsetof(TaskObj, task_awaited_by_is_set),

.task_coro = offsetof(TaskObj, task_coro),

.task_node = offsetof(TaskObj, task_node),

},

.asyncio_interpreter_state = {

.size = sizeof(PyInterpreterState),

.asyncio_tasks_head = offsetof(PyInterpreterState, asyncio_tasks_head),

},

.asyncio_thread_state = {

.size = sizeof(_PyThreadStateImpl),

.asyncio_running_loop = offsetof(_PyThreadStateImpl, asyncio_running_loop),

.asyncio_running_task = offsetof(_PyThreadStateImpl, asyncio_running_task),

.asyncio_tasks_head = offsetof(_PyThreadStateImpl, asyncio_tasks_head),

}};

typedef struct {

PyTypeObject *FutureIterType;

PyTypeObject *TaskStepMethWrapper_Type;

PyTypeObject *FutureType;

PyTypeObject *TaskType;

PyObject *asyncio_mod;

PyObject *context_kwname;

/* WeakSet containing scheduled 3rd party tasks which don't

PyObject *non_asyncio_tasks;

/* Set containing all 3rd party eagerly executing tasks which don't

PyObject *non_asyncio_eager_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;

/* Counter for autogenerated Task names */

uint64_t task_name_counter;

/* Pointer to the asyncio debug offset to avoid it to be optimized away

void *debug_offsets;

} 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);

}

#include "clinic/_asynciomodule.c.h"

static PyObject * future_new_iter(PyObject *);

static PyObject *

task_step_handle_result_impl(asyncio_state *state, TaskObj *task, PyObject *result);

static void unregister_task(TaskObj *task);

static void

clear_task_coro(TaskObj *task)

{

Py_CLEAR(task->task_coro);

}

static void

set_task_coro(TaskObj *task, PyObject *coro)

{

assert(coro != NULL);

Py_INCREF(coro);

Py_XSETREF(task->task_coro, coro);

}

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_GetOptionalAttr(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 PyObject *

get_event_loop(asyncio_state *state)

{

PyObject *loop;

PyObject *policy;

_PyThreadStateImpl *ts = (_PyThreadStateImpl *)_PyThreadState_GET();

loop = Py_XNewRef(ts->asyncio_running_loop);

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_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(fut);

assert(fut->fut_state != STATE_PENDING);

if (Task_Check(state, fut)) {

// remove task from linked-list of tasks

// as it is finished now

TaskObj *task = (TaskObj *)fut;

unregister_task(task);

}

if (fut->fut_callback0 != NULL) {

/* There's a 1st callback */

// Beware: An evil call_soon could alter fut_callback0 or fut_context0.

// Since we are anyway clearing them after the call, whether call_soon

// succeeds or not, the idea is to transfer ownership so that external

// code is not able to alter them during the call.

PyObject *fut_callback0 = fut->fut_callback0;

fut->fut_callback0 = NULL;

PyObject *fut_context0 = fut->fut_context0;

fut->fut_context0 = NULL;

int ret = call_soon(state, fut->fut_loop, fut_callback0,

(PyObject *)fut, fut_context0);

Py_CLEAR(fut_callback0);

Py_CLEAR(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;

}

// Beware: An evil call_soon could change fut->fut_callbacks.

// The idea is to transfer the ownership of the callbacks list

// so that external code is not able to mutate the list during

// the iteration.

PyObject *callbacks = fut->fut_callbacks;

fut->fut_callbacks = NULL;

Py_ssize_t n = PyList_GET_SIZE(callbacks);

for (Py_ssize_t i = 0; i < n; i++) {

assert(PyList_GET_SIZE(callbacks) == n);

PyObject *cb_tup = PyList_GET_ITEM(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)) {

Py_DECREF(callbacks);

return -1;

}

}

Py_DECREF(callbacks);

return 0;

}

static int

future_init(FutureObj *fut, PyObject *loop)

{

PyObject *res;

int is_true;

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->fut_awaited_by);

fut->fut_state = STATE_PENDING;

fut->fut_log_tb = 0;

fut->fut_blocking = 0;

fut->fut_awaited_by_is_set = 0;

fut->fut_is_task = 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_IsInterpreterFinalizing(_PyInterpreterState_GET())) {

/* 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 int

future_awaited_by_add(asyncio_state *state, FutureObj *fut, PyObject *thing)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(fut);

// We only want to support native asyncio Futures.

// For further insight see the comment in the Python

// implementation of "future_add_to_awaited_by()".

assert(TaskOrFuture_Check(state, fut));

assert(TaskOrFuture_Check(state, thing));

/* Most futures/task are only awaited by one entity, so we want

if (fut->fut_awaited_by == NULL) {

assert(!fut->fut_awaited_by_is_set);

Py_INCREF(thing);

fut->fut_awaited_by = thing;

return 0;

}

if (fut->fut_awaited_by_is_set) {

assert(PySet_CheckExact(fut->fut_awaited_by));

return PySet_Add(fut->fut_awaited_by, thing);

}

PyObject *set = PySet_New(NULL);

if (set == NULL) {

return -1;

}

if (PySet_Add(set, thing)) {

Py_DECREF(set);

return -1;

}

if (PySet_Add(set, fut->fut_awaited_by)) {

Py_DECREF(set);

return -1;

}

Py_SETREF(fut->fut_awaited_by, set);

fut->fut_awaited_by_is_set = 1;

return 0;

}

static int

future_awaited_by_discard(asyncio_state *state, FutureObj *fut, PyObject *thing)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(fut);

// We only want to support native asyncio Futures.

// For further insight see the comment in the Python

// implementation of "future_add_to_awaited_by()".

assert(TaskOrFuture_Check(state, fut));

assert(TaskOrFuture_Check(state, thing));

/* Following the semantics of 'set.discard()' here in not

if (fut->fut_awaited_by == NULL) {

return 0;

}

if (fut->fut_awaited_by == thing) {

Py_CLEAR(fut->fut_awaited_by);

return 0;

}

if (fut->fut_awaited_by_is_set) {

assert(PySet_CheckExact(fut->fut_awaited_by));

int err = PySet_Discard(fut->fut_awaited_by, thing);

if (err < 0) {

return -1;

} else {

return 0;

}

}

return 0;

}

static PyObject *

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

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(fut);

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)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(fut);

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 (PyErr_GivenExceptionMatches(exc_val, PyExc_StopIteration)) {

const char *msg = "StopIteration interacts badly with "

"generators and cannot be raised into a "

"Future";

PyObject *message = PyUnicode_FromString(msg);

if (message == NULL) {

Py_DECREF(exc_val);

return NULL;

}

PyObject *err = PyObject_CallOneArg(PyExc_RuntimeError, message);

Py_DECREF(message);

if (err == NULL) {

Py_DECREF(exc_val);

return NULL;

}

assert(PyExceptionInstance_Check(err));

PyException_SetCause(err, Py_NewRef(exc_val));

PyException_SetContext(err, Py_NewRef(exc_val));

Py_DECREF(exc_val);

exc_val = err;

}

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)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(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)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(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)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(fut);

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)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(fut);

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)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(fut);

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(PyObject *op)

{

FutureObj *fut = (FutureObj*)op;

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->fut_awaited_by);

fut->fut_awaited_by_is_set = 0;

PyObject_ClearManagedDict((PyObject *)fut);

return 0;

}

static int

FutureObj_traverse(PyObject *op, visitproc visit, void *arg)

{

FutureObj *fut = (FutureObj*)op;

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->fut_awaited_by);

return PyObject_VisitManagedDict((PyObject *)fut, visit, arg);

}

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;