#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#endif

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

/*[clinic input]

module _asyncio

[clinic start generated code]*/

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

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 \

so that these and bitfields from TaskObj are contiguous. \

*/ \

unsigned prefix##_log_tb: 1; \

unsigned prefix##_blocking: 1; \

typedef struct {

FutureObj_HEAD(fut)

} FutureObj;

typedef struct TaskObj {

FutureObj_HEAD(task)

unsigned task_must_cancel: 1;

unsigned task_log_destroy_pending: 1;

int task_num_cancels_requested;

PyObject *task_fut_waiter;

PyObject *task_coro;

PyObject *task_name;

PyObject *task_context;

struct llist_node task_node;

#ifdef Py_GIL_DISABLED

// thread id of the thread where this task was created

uintptr_t task_tid;

#endif

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

// This macro is optimized to quickly return for native Future *or* Task

// objects by inlining fast "exact" checks to be called first.

#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 {

struct _asyncio_task_object {

uint64_t size;

uint64_t task_name;

uint64_t task_awaited_by;

uint64_t task_is_task;

uint64_t task_awaited_by_is_set;

uint64_t task_coro;

uint64_t task_node;

} asyncio_task_object;

struct _asyncio_interpreter_state {

uint64_t size;

uint64_t asyncio_tasks_head;

} asyncio_interpreter_state;

struct _asyncio_thread_state {

uint64_t size;

uint64_t asyncio_running_loop;

uint64_t asyncio_running_task;

uint64_t asyncio_tasks_head;

} asyncio_thread_state;

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

}};

/* State of the _asyncio module */

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

inherit from native asyncio.Task */

PyObject *non_asyncio_tasks;

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

inherit from native asyncio.Task */

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

by the compiler */

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"

/*[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 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()

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_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,

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;

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

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

to avoid always creating a set for `fut_awaited_by`.

*/

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

raising an error if `thing` isn't in the `awaited_by` "set".

*/

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

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)

{

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

}

/*[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(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);

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

return 0;

}

/*[clinic input]

@critical_section

_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=61d89f48e4c8b670]*/

{

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;