#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#endif

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

/*[clinic input]

module _asyncio

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=8fd17862aa989c69]*/

#define FI_FREELIST_MAXLEN 255

typedef struct futureiterobject futureiterobject;

/* State of the _asyncio module */

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

all running event loops. {EventLoop: Task} */

PyObject *current_tasks;

/* WeakSet containing all tasks scheduled to run on event loops. */

PyObject *scheduled_tasks;

/* Set containing all eagerly executing tasks. */

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

PyObject *cached_running_loop; // Borrowed reference

volatile uint64_t cached_running_loop_tsid;

/* Counter for autogenerated Task names */

uint64_t task_name_counter;

futureiterobject *fi_freelist;

Py_ssize_t fi_freelist_len;

} 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"

/*[clinic input]

class _asyncio.Future "FutureObj *" "&Future_Type"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=00d3e4abca711e0f]*/

/* Get FutureIter from Future */

static PyObject * future_new_iter(PyObject *);

static PyObject *

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

static int

_is_coroutine(asyncio_state *state, PyObject *coro)

{

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

to check if it's another coroutine flavour.

Do this check after 'future_init()'; in case we need to raise

an error, __del__ needs a properly initialized object.

*/

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

positive types. That shouldn't ever happen, unless

someone stressing the system on purpose.

*/

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.

Caching makes is_coroutine() function almost as fast as

PyCoro_CheckExact() for non-native coroutine-like objects

(like coroutines compiled with Cython).

asyncio.iscoroutine() has its own type caching mechanism.

This cache allows us to avoid the cost of even calling

a pure-Python function in 99.9% cases.

*/

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

type(coro) is in iscoroutine_typecache

*/

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)

{

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,

all callbacks are cleared. */

Py_CLEAR(fut->fut_callbacks);

return ret;

}

/* we called the first callback, now try calling

callbacks from the 'fut_callbacks' list. */

}

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;

// 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_IsInterpreterFinalizing(PyInterpreterState_Get())) {

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

finalized. The original motivation to add a `_Py_IsFinalizing()`

call was to prevent SIGSEGV when a Future is created in a __del__

method, which is called during the interpreter shutdown and the

traceback module is already unloaded.

*/

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

{

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

right away. */

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

return NULL;

}

}

else {

/* The future is pending, add a callback.

Callbacks in the future object are stored as follows:

callback0 -- a pointer to the first callback

callbacks -- a list of 2nd, 3rd, ... callbacks

Invariants:

* callbacks != NULL:

There are some callbacks in in the list. Just

add the new callback to it.

* callbacks == NULL and callback0 == NULL:

This is the first callback. Set it to callback0.

* callbacks == NULL and callback0 != NULL:

This is a second callback. Initialize callbacks

with a new list and add the new callback to it.

*/

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;

}

/*[clinic input]

_asyncio.Future.__init__

*

loop: object = None

This class is *almost* compatible with concurrent.futures.Future.

Differences:

- result() and exception() do not take a timeout argument and

raise an exception when the future isn't done yet.

- Callbacks registered with add_done_callback() are always called

via the event loop's call_soon_threadsafe().

- This class is not compatible with the wait() and as_completed()

methods in the concurrent.futures package.

[clinic start generated code]*/

static int

_asyncio_Future___init___impl(FutureObj *self, PyObject *loop)

/*[clinic end generated code: output=9ed75799eaccb5d6 input=89af317082bc0bf8]*/

{

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;

}

/*[clinic input]

_asyncio.Future.result

Return the result this future represents.

If the future has been cancelled, raises CancelledError. If the

future's result isn't yet available, raises InvalidStateError. If

the future is done and has an exception set, this exception is raised.

[clinic start generated code]*/

static PyObject *

_asyncio_Future_result_impl(FutureObj *self)

/*[clinic end generated code: output=f35f940936a4b1e5 input=49ecf9cf5ec50dc5]*/

{

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;

}

/*[clinic input]

_asyncio.Future.exception

cls: defining_class

/

Return the exception that was set on this future.

The exception (or None if no exception was set) is returned only if

the future is done. If the future has been cancelled, raises

CancelledError. If the future isn't done yet, raises

InvalidStateError.

[clinic start generated code]*/

static PyObject *

_asyncio_Future_exception_impl(FutureObj *self, PyTypeObject *cls)

/*[clinic end generated code: output=ce75576b187c905b input=3faf15c22acdb60d]*/

{

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;

}

/*[clinic input]

_asyncio.Future.set_result

cls: defining_class

result: object

/

Mark the future done and set its result.

If the future is already done when this method is called, raises

InvalidStateError.

[clinic start generated code]*/

static PyObject *

_asyncio_Future_set_result_impl(FutureObj *self, PyTypeObject *cls,

PyObject *result)

/*[clinic end generated code: output=99afbbe78f99c32d input=d5a41c1e353acc2e]*/

{

asyncio_state *state = get_asyncio_state_by_cls(cls);

ENSURE_FUTURE_ALIVE(state, self)

return future_set_result(state, self, result);

}

/*[clinic input]

_asyncio.Future.set_exception

cls: defining_class

exception: object

/

Mark the future done and set an exception.

If the future is already done when this method is called, raises

InvalidStateError.

[clinic start generated code]*/

static PyObject *

_asyncio_Future_set_exception_impl(FutureObj *self, PyTypeObject *cls,

PyObject *exception)

/*[clinic end generated code: output=0a5e8b5a52f058d6 input=a245cd49d3df939b]*/

{

asyncio_state *state = get_asyncio_state_by_cls(cls);

ENSURE_FUTURE_ALIVE(state, self)

return future_set_exception(state, self, exception);

}

/*[clinic input]

_asyncio.Future.add_done_callback

cls: defining_class

fn: object

/

*

context: object = NULL

Add a callback to be run when the future becomes done.

The callback is called with a single argument - the future object. If

the future is already done when this is called, the callback is