LCOV - code coverage report
Current view: | top level - Modules - _asynciomodule.c (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 102 | 1380 | 7.4 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 8 | 114 | 7.0 %
|  |  | Branches: | 127 | 1027 | 12.4 %

               Branch data     Line data    Source code
           1                 :            : #ifndef Py_BUILD_CORE_BUILTIN
           2                 :            : #  define Py_BUILD_CORE_MODULE 1
           3                 :            : #endif
           4                 :            :
           5                 :            : #include "Python.h"
           6                 :            : #include "pycore_pyerrors.h"      // _PyErr_ClearExcState()
           7                 :            : #include "pycore_pystate.h"       // _PyThreadState_GET()
           8                 :            : #include "pycore_runtime_init.h"  // _Py_ID()
           9                 :            : #include "pycore_moduleobject.h"  // _PyModule_GetState()
          10                 :            : #include "structmember.h"         // PyMemberDef
          11                 :            : #include <stddef.h>               // offsetof()
          12                 :            :
          13                 :            :
          14                 :            : /*[clinic input]
          15                 :            : module _asyncio
          16                 :            : [clinic start generated code]*/
          17                 :            : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=8fd17862aa989c69]*/
          18                 :            :
          19                 :            :
          20                 :            : /* State of the _asyncio module */
          21                 :            : typedef struct {
          22                 :            :     PyTypeObject *FutureIterType;
          23                 :            :     PyTypeObject *TaskStepMethWrapper_Type;
          24                 :            :     PyTypeObject *FutureType;
          25                 :            :     PyTypeObject *TaskType;
          26                 :            :
          27                 :            :     PyObject *asyncio_mod;
          28                 :            :     PyObject *context_kwname;
          29                 :            :
          30                 :            :     /* Dictionary containing tasks that are currently active in
          31                 :            :        all running event loops.  {EventLoop: Task} */
          32                 :            :     PyObject *current_tasks;
          33                 :            :
          34                 :            :     /* WeakSet containing all alive tasks. */
          35                 :            :     PyObject *all_tasks;
          36                 :            :
          37                 :            :     /* An isinstance type cache for the 'is_coroutine()' function. */
          38                 :            :     PyObject *iscoroutine_typecache;
          39                 :            :
          40                 :            :     /* Imports from asyncio.events. */
          41                 :            :     PyObject *asyncio_get_event_loop_policy;
          42                 :            :
          43                 :            :     /* Imports from asyncio.base_futures. */
          44                 :            :     PyObject *asyncio_future_repr_func;
          45                 :            :
          46                 :            :     /* Imports from asyncio.exceptions. */
          47                 :            :     PyObject *asyncio_CancelledError;
          48                 :            :     PyObject *asyncio_InvalidStateError;
          49                 :            :
          50                 :            :     /* Imports from asyncio.base_tasks. */
          51                 :            :     PyObject *asyncio_task_get_stack_func;
          52                 :            :     PyObject *asyncio_task_print_stack_func;
          53                 :            :     PyObject *asyncio_task_repr_func;
          54                 :            :
          55                 :            :     /* Imports from asyncio.coroutines. */
          56                 :            :     PyObject *asyncio_iscoroutine_func;
          57                 :            :
          58                 :            :     /* Imports from traceback. */
          59                 :            :     PyObject *traceback_extract_stack;
          60                 :            :
          61                 :            :     PyObject *cached_running_loop; // Borrowed reference
          62                 :            :     volatile uint64_t cached_running_loop_tsid;
          63                 :            :
          64                 :            :     /* Counter for autogenerated Task names */
          65                 :            :     uint64_t task_name_counter;
          66                 :            : } asyncio_state;
          67                 :            :
          68                 :            : static inline asyncio_state *
          69                 :         13 : get_asyncio_state(PyObject *mod)
          70                 :            : {
          71                 :         13 :     asyncio_state *state = _PyModule_GetState(mod);
          72                 :            :     assert(state != NULL);
          73                 :         13 :     return state;
          74                 :            : }
          75                 :            :
          76                 :            : static inline asyncio_state *
          77                 :          0 : get_asyncio_state_by_cls(PyTypeObject *cls)
          78                 :            : {
          79                 :          0 :     asyncio_state *state = (asyncio_state *)_PyType_GetModuleState(cls);
          80                 :            :     assert(state != NULL);
          81                 :          0 :     return state;
          82                 :            : }
          83                 :            :
          84                 :            : static struct PyModuleDef _asynciomodule;
          85                 :            :
          86                 :            : static inline asyncio_state *
          87                 :          0 : get_asyncio_state_by_def(PyObject *self)
          88                 :            : {
          89                 :          0 :     PyTypeObject *tp = Py_TYPE(self);
          90                 :          0 :     PyObject *mod = PyType_GetModuleByDef(tp, &_asynciomodule);
          91                 :            :     assert(mod != NULL);
          92                 :          0 :     return get_asyncio_state(mod);
          93                 :            : }
          94                 :            :
          95                 :            : typedef enum {
          96                 :            :     STATE_PENDING,
          97                 :            :     STATE_CANCELLED,
          98                 :            :     STATE_FINISHED
          99                 :            : } fut_state;
         100                 :            :
         101                 :            : #define FutureObj_HEAD(prefix)                                              \
         102                 :            :     PyObject_HEAD                                                           \
         103                 :            :     PyObject *prefix##_loop;                                                \
         104                 :            :     PyObject *prefix##_callback0;                                           \
         105                 :            :     PyObject *prefix##_context0;                                            \
         106                 :            :     PyObject *prefix##_callbacks;                                           \
         107                 :            :     PyObject *prefix##_exception;                                           \
         108                 :            :     PyObject *prefix##_exception_tb;                                        \
         109                 :            :     PyObject *prefix##_result;                                              \
         110                 :            :     PyObject *prefix##_source_tb;                                           \
         111                 :            :     PyObject *prefix##_cancel_msg;                                          \
         112                 :            :     fut_state prefix##_state;                                               \
         113                 :            :     int prefix##_log_tb;                                                    \
         114                 :            :     int prefix##_blocking;                                                  \
         115                 :            :     PyObject *dict;                                                         \
         116                 :            :     PyObject *prefix##_weakreflist;                                         \
         117                 :            :     PyObject *prefix##_cancelled_exc;
         118                 :            :
         119                 :            : typedef struct {
         120                 :            :     FutureObj_HEAD(fut)
         121                 :            : } FutureObj;
         122                 :            :
         123                 :            : typedef struct {
         124                 :            :     FutureObj_HEAD(task)
         125                 :            :     PyObject *task_fut_waiter;
         126                 :            :     PyObject *task_coro;
         127                 :            :     PyObject *task_name;
         128                 :            :     PyObject *task_context;
         129                 :            :     int task_must_cancel;
         130                 :            :     int task_log_destroy_pending;
         131                 :            :     int task_num_cancels_requested;
         132                 :            : } TaskObj;
         133                 :            :
         134                 :            : typedef struct {
         135                 :            :     PyObject_HEAD
         136                 :            :     TaskObj *sw_task;
         137                 :            :     PyObject *sw_arg;
         138                 :            : } TaskStepMethWrapper;
         139                 :            :
         140                 :            :
         141                 :            : #define Future_CheckExact(state, obj) Py_IS_TYPE(obj, state->FutureType)
         142                 :            : #define Task_CheckExact(state, obj) Py_IS_TYPE(obj, state->TaskType)
         143                 :            :
         144                 :            : #define Future_Check(state, obj) PyObject_TypeCheck(obj, state->FutureType)
         145                 :            : #define Task_Check(state, obj) PyObject_TypeCheck(obj, state->TaskType)
         146                 :            :
         147                 :            : #include "clinic/_asynciomodule.c.h"
         148                 :            :
         149                 :            :
         150                 :            : /*[clinic input]
         151                 :            : class _asyncio.Future "FutureObj *" "&Future_Type"
         152                 :            : [clinic start generated code]*/
         153                 :            : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=00d3e4abca711e0f]*/
         154                 :            :
         155                 :            :
         156                 :            : /* Get FutureIter from Future */
         157                 :            : static PyObject * future_new_iter(PyObject *);
         158                 :            :
         159                 :            :
         160                 :            : static int
         161                 :          0 : _is_coroutine(asyncio_state *state, PyObject *coro)
         162                 :            : {
         163                 :            :     /* 'coro' is not a native coroutine, call asyncio.iscoroutine()
         164                 :            :        to check if it's another coroutine flavour.
         165                 :            :
         166                 :            :        Do this check after 'future_init()'; in case we need to raise
         167                 :            :        an error, __del__ needs a properly initialized object.
         168                 :            :     */
         169                 :          0 :     PyObject *res = PyObject_CallOneArg(state->asyncio_iscoroutine_func, coro);
         170         [ #  # ]:          0 :     if (res == NULL) {
         171                 :          0 :         return -1;
         172                 :            :     }
         173                 :            :
         174                 :          0 :     int is_res_true = PyObject_IsTrue(res);
         175                 :          0 :     Py_DECREF(res);
         176         [ #  # ]:          0 :     if (is_res_true <= 0) {
         177                 :          0 :         return is_res_true;
         178                 :            :     }
         179                 :            :
         180         [ #  # ]:          0 :     if (PySet_GET_SIZE(state->iscoroutine_typecache) < 100) {
         181                 :            :         /* Just in case we don't want to cache more than 100
         182                 :            :            positive types.  That shouldn't ever happen, unless
         183                 :            :            someone stressing the system on purpose.
         184                 :            :         */
         185         [ #  # ]:          0 :         if (PySet_Add(state->iscoroutine_typecache, (PyObject*) Py_TYPE(coro))) {
         186                 :          0 :             return -1;
         187                 :            :         }
         188                 :            :     }
         189                 :            :
         190                 :          0 :     return 1;
         191                 :            : }
         192                 :            :
         193                 :            :
         194                 :            : static inline int
         195                 :          0 : is_coroutine(asyncio_state *state, PyObject *coro)
         196                 :            : {
         197         [ #  # ]:          0 :     if (PyCoro_CheckExact(coro)) {
         198                 :          0 :         return 1;
         199                 :            :     }
         200                 :            :
         201                 :            :     /* Check if `type(coro)` is in the cache.
         202                 :            :        Caching makes is_coroutine() function almost as fast as
         203                 :            :        PyCoro_CheckExact() for non-native coroutine-like objects
         204                 :            :        (like coroutines compiled with Cython).
         205                 :            :
         206                 :            :        asyncio.iscoroutine() has its own type caching mechanism.
         207                 :            :        This cache allows us to avoid the cost of even calling
         208                 :            :        a pure-Python function in 99.9% cases.
         209                 :            :     */
         210                 :          0 :     int has_it = PySet_Contains(
         211                 :          0 :         state->iscoroutine_typecache, (PyObject*) Py_TYPE(coro));
         212         [ #  # ]:          0 :     if (has_it == 0) {
         213                 :            :         /* type(coro) is not in iscoroutine_typecache */
         214                 :          0 :         return _is_coroutine(state, coro);
         215                 :            :     }
         216                 :            :
         217                 :            :     /* either an error has occurred or
         218                 :            :        type(coro) is in iscoroutine_typecache
         219                 :            :     */
         220                 :          0 :     return has_it;
         221                 :            : }
         222                 :            :
         223                 :            :
         224                 :            : static PyObject *
         225                 :          0 : get_future_loop(asyncio_state *state, PyObject *fut)
         226                 :            : {
         227                 :            :     /* Implementation of `asyncio.futures._get_loop` */
         228                 :            :
         229                 :            :     PyObject *getloop;
         230                 :            :
         231   [ #  #  #  # ]:          0 :     if (Future_CheckExact(state, fut) || Task_CheckExact(state, fut)) {
         232                 :          0 :         PyObject *loop = ((FutureObj *)fut)->fut_loop;
         233                 :          0 :         return Py_NewRef(loop);
         234                 :            :     }
         235                 :            :
         236         [ #  # ]:          0 :     if (_PyObject_LookupAttr(fut, &_Py_ID(get_loop), &getloop) < 0) {
         237                 :          0 :         return NULL;
         238                 :            :     }
         239         [ #  # ]:          0 :     if (getloop != NULL) {
         240                 :          0 :         PyObject *res = PyObject_CallNoArgs(getloop);
         241                 :          0 :         Py_DECREF(getloop);
         242                 :          0 :         return res;
         243                 :            :     }
         244                 :            :
         245                 :          0 :     return PyObject_GetAttr(fut, &_Py_ID(_loop));
         246                 :            : }
         247                 :            :
         248                 :            :
         249                 :            : static int
         250                 :          0 : get_running_loop(asyncio_state *state, PyObject **loop)
         251                 :            : {
         252                 :            :     PyObject *rl;
         253                 :            :
         254                 :          0 :     PyThreadState *ts = _PyThreadState_GET();
         255                 :          0 :     uint64_t ts_id = PyThreadState_GetID(ts);
         256         [ #  # ]:          0 :     if (state->cached_running_loop_tsid == ts_id &&
         257         [ #  # ]:          0 :         state->cached_running_loop != NULL)
         258                 :            :     {
         259                 :            :         // Fast path, check the cache.
         260                 :          0 :         rl = state->cached_running_loop;
         261                 :            :     }
         262                 :            :     else {
         263                 :          0 :         PyObject *ts_dict = _PyThreadState_GetDict(ts);  // borrowed
         264         [ #  # ]:          0 :         if (ts_dict == NULL) {
         265                 :          0 :             goto not_found;
         266                 :            :         }
         267                 :            :
         268                 :          0 :         rl = PyDict_GetItemWithError(
         269                 :            :             ts_dict, &_Py_ID(__asyncio_running_event_loop__));  // borrowed
         270         [ #  # ]:          0 :         if (rl == NULL) {
         271         [ #  # ]:          0 :             if (PyErr_Occurred()) {
         272                 :          0 :                 goto error;
         273                 :            :             }
         274                 :            :             else {
         275                 :          0 :                 goto not_found;
         276                 :            :             }
         277                 :            :         }
         278                 :            :
         279                 :          0 :         state->cached_running_loop = rl;
         280                 :          0 :         state->cached_running_loop_tsid = ts_id;
         281                 :            :     }
         282                 :            :
         283                 :            :
         284         [ #  # ]:          0 :     if (rl == Py_None) {
         285                 :          0 :         goto not_found;
         286                 :            :     }
         287                 :            :
         288                 :          0 :     *loop = Py_NewRef(rl);
         289                 :          0 :     return 0;
         290                 :            :
         291                 :          0 : not_found:
         292                 :          0 :     *loop = NULL;
         293                 :          0 :     return 0;
         294                 :            :
         295                 :          0 : error:
         296                 :          0 :     *loop = NULL;
         297                 :          0 :     return -1;
         298                 :            : }
         299                 :            :
         300                 :            :
         301                 :            : static int
         302                 :          0 : set_running_loop(asyncio_state *state, PyObject *loop)
         303                 :            : {
         304                 :          0 :     PyObject *ts_dict = NULL;
         305                 :            :
         306                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
         307         [ #  # ]:          0 :     if (tstate != NULL) {
         308                 :          0 :         ts_dict = _PyThreadState_GetDict(tstate);  // borrowed
         309                 :            :     }
         310                 :            :
         311         [ #  # ]:          0 :     if (ts_dict == NULL) {
         312                 :          0 :         PyErr_SetString(
         313                 :            :             PyExc_RuntimeError, "thread-local storage is not available");
         314                 :          0 :         return -1;
         315                 :            :     }
         316         [ #  # ]:          0 :     if (PyDict_SetItem(
         317                 :            :             ts_dict, &_Py_ID(__asyncio_running_event_loop__), loop) < 0)
         318                 :            :     {
         319                 :          0 :         return -1;
         320                 :            :     }
         321                 :            :
         322                 :          0 :     state->cached_running_loop = loop; // borrowed, kept alive by ts_dict
         323                 :          0 :     state->cached_running_loop_tsid = PyThreadState_GetID(tstate);
         324                 :            :
         325                 :          0 :     return 0;
         326                 :            : }
         327                 :            :
         328                 :            :
         329                 :            : static PyObject *
         330                 :          0 : get_event_loop(asyncio_state *state)
         331                 :            : {
         332                 :            :     PyObject *loop;
         333                 :            :     PyObject *policy;
         334                 :            :
         335         [ #  # ]:          0 :     if (get_running_loop(state, &loop)) {
         336                 :          0 :         return NULL;
         337                 :            :     }
         338         [ #  # ]:          0 :     if (loop != NULL) {
         339                 :          0 :         return loop;
         340                 :            :     }
         341                 :            :
         342                 :          0 :     policy = PyObject_CallNoArgs(state->asyncio_get_event_loop_policy);
         343         [ #  # ]:          0 :     if (policy == NULL) {
         344                 :          0 :         return NULL;
         345                 :            :     }
         346                 :            :
         347                 :          0 :     loop = PyObject_CallMethodNoArgs(policy, &_Py_ID(get_event_loop));
         348                 :          0 :     Py_DECREF(policy);
         349                 :          0 :     return loop;
         350                 :            : }
         351                 :            :
         352                 :            :
         353                 :            : static int
         354                 :          0 : call_soon(asyncio_state *state, PyObject *loop, PyObject *func, PyObject *arg,
         355                 :            :           PyObject *ctx)
         356                 :            : {
         357                 :            :     PyObject *handle;
         358                 :            :     PyObject *stack[3];
         359                 :            :     Py_ssize_t nargs;
         360                 :            :
         361         [ #  # ]:          0 :     if (ctx == NULL) {
         362                 :          0 :         handle = PyObject_CallMethodObjArgs(
         363                 :            :             loop, &_Py_ID(call_soon), func, arg, NULL);
         364                 :            :     }
         365                 :            :     else {
         366                 :            :         /* Use FASTCALL to pass a keyword-only argument to call_soon */
         367                 :            :
         368                 :          0 :         PyObject *callable = PyObject_GetAttr(loop, &_Py_ID(call_soon));
         369         [ #  # ]:          0 :         if (callable == NULL) {
         370                 :          0 :             return -1;
         371                 :            :         }
         372                 :            :
         373                 :            :         /* All refs in 'stack' are borrowed. */
         374                 :          0 :         nargs = 1;
         375                 :          0 :         stack[0] = func;
         376         [ #  # ]:          0 :         if (arg != NULL) {
         377                 :          0 :             stack[1] = arg;
         378                 :          0 :             nargs++;
         379                 :            :         }
         380                 :          0 :         stack[nargs] = (PyObject *)ctx;
         381                 :            :         EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_API, callable);
         382                 :          0 :         handle = PyObject_Vectorcall(callable, stack, nargs,
         383                 :            :                                      state->context_kwname);
         384                 :          0 :         Py_DECREF(callable);
         385                 :            :     }
         386                 :            :
         387         [ #  # ]:          0 :     if (handle == NULL) {
         388                 :          0 :         return -1;
         389                 :            :     }
         390                 :          0 :     Py_DECREF(handle);
         391                 :          0 :     return 0;
         392                 :            : }
         393                 :            :
         394                 :            :
         395                 :            : static inline int
         396                 :          0 : future_is_alive(FutureObj *fut)
         397                 :            : {
         398                 :          0 :     return fut->fut_loop != NULL;
         399                 :            : }
         400                 :            :
         401                 :            :
         402                 :            : static inline int
         403                 :          0 : future_ensure_alive(FutureObj *fut)
         404                 :            : {
         405         [ #  # ]:          0 :     if (!future_is_alive(fut)) {
         406                 :          0 :         PyErr_SetString(PyExc_RuntimeError,
         407                 :            :                         "Future object is not initialized.");
         408                 :          0 :         return -1;
         409                 :            :     }
         410                 :          0 :     return 0;
         411                 :            : }
         412                 :            :
         413                 :            :
         414                 :            : #define ENSURE_FUTURE_ALIVE(state, fut)                             \
         415                 :            :     do {                                                            \
         416                 :            :         assert(Future_Check(state, fut) || Task_Check(state, fut)); \
         417                 :            :         (void)state;                                                \
         418                 :            :         if (future_ensure_alive((FutureObj*)fut)) {                 \
         419                 :            :             return NULL;                                            \
         420                 :            :         }                                                           \
         421                 :            :     } while(0);
         422                 :            :
         423                 :            :
         424                 :            : static int
         425                 :          0 : future_schedule_callbacks(asyncio_state *state, FutureObj *fut)
         426                 :            : {
         427                 :            :     Py_ssize_t len;
         428                 :            :     Py_ssize_t i;
         429                 :            :
         430         [ #  # ]:          0 :     if (fut->fut_callback0 != NULL) {
         431                 :            :         /* There's a 1st callback */
         432                 :            :
         433                 :          0 :         int ret = call_soon(state,
         434                 :            :             fut->fut_loop, fut->fut_callback0,
         435                 :            :             (PyObject *)fut, fut->fut_context0);
         436                 :            :
         437         [ #  # ]:          0 :         Py_CLEAR(fut->fut_callback0);
         438         [ #  # ]:          0 :         Py_CLEAR(fut->fut_context0);
         439         [ #  # ]:          0 :         if (ret) {
         440                 :            :             /* If an error occurs in pure-Python implementation,
         441                 :            :                all callbacks are cleared. */
         442         [ #  # ]:          0 :             Py_CLEAR(fut->fut_callbacks);
         443                 :          0 :             return ret;
         444                 :            :         }
         445                 :            :
         446                 :            :         /* we called the first callback, now try calling
         447                 :            :            callbacks from the 'fut_callbacks' list. */
         448                 :            :     }
         449                 :            :
         450         [ #  # ]:          0 :     if (fut->fut_callbacks == NULL) {
         451                 :            :         /* No more callbacks, return. */
         452                 :          0 :         return 0;
         453                 :            :     }
         454                 :            :
         455                 :          0 :     len = PyList_GET_SIZE(fut->fut_callbacks);
         456         [ #  # ]:          0 :     if (len == 0) {
         457                 :            :         /* The list of callbacks was empty; clear it and return. */
         458         [ #  # ]:          0 :         Py_CLEAR(fut->fut_callbacks);
         459                 :          0 :         return 0;
         460                 :            :     }
         461                 :            :
         462         [ #  # ]:          0 :     for (i = 0; i < len; i++) {
         463                 :          0 :         PyObject *cb_tup = PyList_GET_ITEM(fut->fut_callbacks, i);
         464                 :          0 :         PyObject *cb = PyTuple_GET_ITEM(cb_tup, 0);
         465                 :          0 :         PyObject *ctx = PyTuple_GET_ITEM(cb_tup, 1);
         466                 :            :
         467         [ #  # ]:          0 :         if (call_soon(state, fut->fut_loop, cb, (PyObject *)fut, ctx)) {
         468                 :            :             /* If an error occurs in pure-Python implementation,
         469                 :            :                all callbacks are cleared. */
         470         [ #  # ]:          0 :             Py_CLEAR(fut->fut_callbacks);
         471                 :          0 :             return -1;
         472                 :            :         }
         473                 :            :     }
         474                 :            :
         475         [ #  # ]:          0 :     Py_CLEAR(fut->fut_callbacks);
         476                 :          0 :     return 0;
         477                 :            : }
         478                 :            :
         479                 :            :
         480                 :            : static int
         481                 :          0 : future_init(FutureObj *fut, PyObject *loop)
         482                 :            : {
         483                 :            :     PyObject *res;
         484                 :            :     int is_true;
         485                 :            :
         486                 :            :     // Same to FutureObj_clear() but not clearing fut->dict
         487         [ #  # ]:          0 :     Py_CLEAR(fut->fut_loop);
         488         [ #  # ]:          0 :     Py_CLEAR(fut->fut_callback0);
         489         [ #  # ]:          0 :     Py_CLEAR(fut->fut_context0);
         490         [ #  # ]:          0 :     Py_CLEAR(fut->fut_callbacks);
         491         [ #  # ]:          0 :     Py_CLEAR(fut->fut_result);
         492         [ #  # ]:          0 :     Py_CLEAR(fut->fut_exception);
         493         [ #  # ]:          0 :     Py_CLEAR(fut->fut_exception_tb);
         494         [ #  # ]:          0 :     Py_CLEAR(fut->fut_source_tb);
         495         [ #  # ]:          0 :     Py_CLEAR(fut->fut_cancel_msg);
         496         [ #  # ]:          0 :     Py_CLEAR(fut->fut_cancelled_exc);
         497                 :            :
         498                 :          0 :     fut->fut_state = STATE_PENDING;
         499                 :          0 :     fut->fut_log_tb = 0;
         500                 :          0 :     fut->fut_blocking = 0;
         501                 :            :
         502         [ #  # ]:          0 :     if (loop == Py_None) {
         503                 :          0 :         asyncio_state *state = get_asyncio_state_by_def((PyObject *)fut);
         504                 :          0 :         loop = get_event_loop(state);
         505         [ #  # ]:          0 :         if (loop == NULL) {
         506                 :          0 :             return -1;
         507                 :            :         }
         508                 :            :     }
         509                 :            :     else {
         510                 :          0 :         Py_INCREF(loop);
         511                 :            :     }
         512                 :          0 :     fut->fut_loop = loop;
         513                 :            :
         514                 :          0 :     res = PyObject_CallMethodNoArgs(fut->fut_loop, &_Py_ID(get_debug));
         515         [ #  # ]:          0 :     if (res == NULL) {
         516                 :          0 :         return -1;
         517                 :            :     }
         518                 :          0 :     is_true = PyObject_IsTrue(res);
         519                 :          0 :     Py_DECREF(res);
         520         [ #  # ]:          0 :     if (is_true < 0) {
         521                 :          0 :         return -1;
         522                 :            :     }
         523   [ #  #  #  # ]:          0 :     if (is_true && !_Py_IsFinalizing()) {
         524                 :            :         /* Only try to capture the traceback if the interpreter is not being
         525                 :            :            finalized.  The original motivation to add a `_Py_IsFinalizing()`
         526                 :            :            call was to prevent SIGSEGV when a Future is created in a __del__
         527                 :            :            method, which is called during the interpreter shutdown and the
         528                 :            :            traceback module is already unloaded.
         529                 :            :         */
         530                 :          0 :         asyncio_state *state = get_asyncio_state_by_def((PyObject *)fut);
         531                 :          0 :         fut->fut_source_tb = PyObject_CallNoArgs(state->traceback_extract_stack);
         532         [ #  # ]:          0 :         if (fut->fut_source_tb == NULL) {
         533                 :          0 :             return -1;
         534                 :            :         }
         535                 :            :     }
         536                 :            :
         537                 :          0 :     return 0;
         538                 :            : }
         539                 :            :
         540                 :            : static PyObject *
         541                 :          0 : future_set_result(asyncio_state *state, FutureObj *fut, PyObject *res)
         542                 :            : {
         543         [ #  # ]:          0 :     if (future_ensure_alive(fut)) {
         544                 :          0 :         return NULL;
         545                 :            :     }
         546                 :            :
         547         [ #  # ]:          0 :     if (fut->fut_state != STATE_PENDING) {
         548                 :          0 :         PyErr_SetString(state->asyncio_InvalidStateError, "invalid state");
         549                 :          0 :         return NULL;
         550                 :            :     }
         551                 :            :
         552                 :            :     assert(!fut->fut_result);
         553                 :          0 :     fut->fut_result = Py_NewRef(res);
         554                 :          0 :     fut->fut_state = STATE_FINISHED;
         555                 :            :
         556         [ #  # ]:          0 :     if (future_schedule_callbacks(state, fut) == -1) {
         557                 :          0 :         return NULL;
         558                 :            :     }
         559                 :          0 :     Py_RETURN_NONE;
         560                 :            : }
         561                 :            :
         562                 :            : static PyObject *
         563                 :          0 : future_set_exception(asyncio_state *state, FutureObj *fut, PyObject *exc)
         564                 :            : {
         565                 :          0 :     PyObject *exc_val = NULL;
         566                 :            :
         567         [ #  # ]:          0 :     if (fut->fut_state != STATE_PENDING) {
         568                 :          0 :         PyErr_SetString(state->asyncio_InvalidStateError, "invalid state");
         569                 :          0 :         return NULL;
         570                 :            :     }
         571                 :            :
         572   [ #  #  #  # ]:          0 :     if (PyExceptionClass_Check(exc)) {
         573                 :          0 :         exc_val = PyObject_CallNoArgs(exc);
         574         [ #  # ]:          0 :         if (exc_val == NULL) {
         575                 :          0 :             return NULL;
         576                 :            :         }
         577         [ #  # ]:          0 :         if (fut->fut_state != STATE_PENDING) {
         578                 :          0 :             Py_DECREF(exc_val);
         579                 :          0 :             PyErr_SetString(state->asyncio_InvalidStateError, "invalid state");
         580                 :          0 :             return NULL;
         581                 :            :         }
         582                 :            :     }
         583                 :            :     else {
         584                 :          0 :         exc_val = Py_NewRef(exc);
         585                 :            :     }
         586         [ #  # ]:          0 :     if (!PyExceptionInstance_Check(exc_val)) {
         587                 :          0 :         Py_DECREF(exc_val);
         588                 :          0 :         PyErr_SetString(PyExc_TypeError, "invalid exception object");
         589                 :          0 :         return NULL;
         590                 :            :     }
         591         [ #  # ]:          0 :     if (Py_IS_TYPE(exc_val, (PyTypeObject *)PyExc_StopIteration)) {
         592                 :          0 :         Py_DECREF(exc_val);
         593                 :          0 :         PyErr_SetString(PyExc_TypeError,
         594                 :            :                         "StopIteration interacts badly with generators "
         595                 :            :                         "and cannot be raised into a Future");
         596                 :          0 :         return NULL;
         597                 :            :     }
         598                 :            :
         599                 :            :     assert(!fut->fut_exception);
         600                 :            :     assert(!fut->fut_exception_tb);
         601                 :          0 :     fut->fut_exception = exc_val;
         602                 :          0 :     fut->fut_exception_tb = PyException_GetTraceback(exc_val);
         603                 :          0 :     fut->fut_state = STATE_FINISHED;
         604                 :            :
         605         [ #  # ]:          0 :     if (future_schedule_callbacks(state, fut) == -1) {
         606                 :          0 :         return NULL;
         607                 :            :     }
         608                 :            :
         609                 :          0 :     fut->fut_log_tb = 1;
         610                 :          0 :     Py_RETURN_NONE;
         611                 :            : }
         612                 :            :
         613                 :            : static PyObject *
         614                 :          0 : create_cancelled_error(asyncio_state *state, FutureObj *fut)
         615                 :            : {
         616                 :            :     PyObject *exc;
         617         [ #  # ]:          0 :     if (fut->fut_cancelled_exc != NULL) {
         618                 :            :         /* transfer ownership */
         619                 :          0 :         exc = fut->fut_cancelled_exc;
         620                 :          0 :         fut->fut_cancelled_exc = NULL;
         621                 :          0 :         return exc;
         622                 :            :     }
         623                 :          0 :     PyObject *msg = fut->fut_cancel_msg;
         624   [ #  #  #  # ]:          0 :     if (msg == NULL || msg == Py_None) {
         625                 :          0 :         exc = PyObject_CallNoArgs(state->asyncio_CancelledError);
         626                 :            :     } else {
         627                 :          0 :         exc = PyObject_CallOneArg(state->asyncio_CancelledError, msg);
         628                 :            :     }
         629                 :          0 :     return exc;
         630                 :            : }
         631                 :            :
         632                 :            : static void
         633                 :          0 : future_set_cancelled_error(asyncio_state *state, FutureObj *fut)
         634                 :            : {
         635                 :          0 :     PyObject *exc = create_cancelled_error(state, fut);
         636         [ #  # ]:          0 :     if (exc == NULL) {
         637                 :          0 :         return;
         638                 :            :     }
         639                 :          0 :     PyErr_SetObject(state->asyncio_CancelledError, exc);
         640                 :          0 :     Py_DECREF(exc);
         641                 :            : }
         642                 :            :
         643                 :            : static int
         644                 :          0 : future_get_result(asyncio_state *state, FutureObj *fut, PyObject **result)
         645                 :            : {
         646         [ #  # ]:          0 :     if (fut->fut_state == STATE_CANCELLED) {
         647                 :          0 :         future_set_cancelled_error(state, fut);
         648                 :          0 :         return -1;
         649                 :            :     }
         650                 :            :
         651         [ #  # ]:          0 :     if (fut->fut_state != STATE_FINISHED) {
         652                 :          0 :         PyErr_SetString(state->asyncio_InvalidStateError,
         653                 :            :                         "Result is not set.");
         654                 :          0 :         return -1;
         655                 :            :     }
         656                 :            :
         657                 :          0 :     fut->fut_log_tb = 0;
         658         [ #  # ]:          0 :     if (fut->fut_exception != NULL) {
         659                 :          0 :         PyObject *tb = fut->fut_exception_tb;
         660         [ #  # ]:          0 :         if (tb == NULL) {
         661                 :          0 :             tb = Py_None;
         662                 :            :         }
         663         [ #  # ]:          0 :         if (PyException_SetTraceback(fut->fut_exception, tb) < 0) {
         664                 :          0 :             return -1;
         665                 :            :         }
         666                 :          0 :         *result = Py_NewRef(fut->fut_exception);
         667         [ #  # ]:          0 :         Py_CLEAR(fut->fut_exception_tb);
         668                 :          0 :         return 1;
         669                 :            :     }
         670                 :            :
         671                 :          0 :     *result = Py_NewRef(fut->fut_result);
         672                 :          0 :     return 0;
         673                 :            : }
         674                 :            :
         675                 :            : static PyObject *
         676                 :          0 : future_add_done_callback(asyncio_state *state, FutureObj *fut, PyObject *arg,
         677                 :            :                          PyObject *ctx)
         678                 :            : {
         679         [ #  # ]:          0 :     if (!future_is_alive(fut)) {
         680                 :          0 :         PyErr_SetString(PyExc_RuntimeError, "uninitialized Future object");
         681                 :          0 :         return NULL;
         682                 :            :     }
         683                 :            :
         684         [ #  # ]:          0 :     if (fut->fut_state != STATE_PENDING) {
         685                 :            :         /* The future is done/cancelled, so schedule the callback
         686                 :            :            right away. */
         687         [ #  # ]:          0 :         if (call_soon(state, fut->fut_loop, arg, (PyObject*) fut, ctx)) {
         688                 :          0 :             return NULL;
         689                 :            :         }
         690                 :            :     }
         691                 :            :     else {
         692                 :            :         /* The future is pending, add a callback.
         693                 :            :
         694                 :            :            Callbacks in the future object are stored as follows:
         695                 :            :
         696                 :            :               callback0 -- a pointer to the first callback
         697                 :            :               callbacks -- a list of 2nd, 3rd, ... callbacks
         698                 :            :
         699                 :            :            Invariants:
         700                 :            :
         701                 :            :             * callbacks != NULL:
         702                 :            :                 There are some callbacks in in the list.  Just
         703                 :            :                 add the new callback to it.
         704                 :            :
         705                 :            :             * callbacks == NULL and callback0 == NULL:
         706                 :            :                 This is the first callback.  Set it to callback0.
         707                 :            :
         708                 :            :             * callbacks == NULL and callback0 != NULL:
         709                 :            :                 This is a second callback.  Initialize callbacks
         710                 :            :                 with a new list and add the new callback to it.
         711                 :            :         */
         712                 :            :
         713   [ #  #  #  # ]:          0 :         if (fut->fut_callbacks == NULL && fut->fut_callback0 == NULL) {
         714                 :          0 :             fut->fut_callback0 = Py_NewRef(arg);
         715                 :          0 :             fut->fut_context0 = Py_NewRef(ctx);
         716                 :            :         }
         717                 :            :         else {
         718                 :          0 :             PyObject *tup = PyTuple_New(2);
         719         [ #  # ]:          0 :             if (tup == NULL) {
         720                 :          0 :                 return NULL;
         721                 :            :             }
         722                 :          0 :             Py_INCREF(arg);
         723                 :          0 :             PyTuple_SET_ITEM(tup, 0, arg);
         724                 :          0 :             Py_INCREF(ctx);
         725                 :          0 :             PyTuple_SET_ITEM(tup, 1, (PyObject *)ctx);
         726                 :            :
         727         [ #  # ]:          0 :             if (fut->fut_callbacks != NULL) {
         728                 :          0 :                 int err = PyList_Append(fut->fut_callbacks, tup);
         729         [ #  # ]:          0 :                 if (err) {
         730                 :          0 :                     Py_DECREF(tup);
         731                 :          0 :                     return NULL;
         732                 :            :                 }
         733                 :          0 :                 Py_DECREF(tup);
         734                 :            :             }
         735                 :            :             else {
         736                 :          0 :                 fut->fut_callbacks = PyList_New(1);
         737         [ #  # ]:          0 :                 if (fut->fut_callbacks == NULL) {
         738                 :          0 :                     Py_DECREF(tup);
         739                 :          0 :                     return NULL;
         740                 :            :                 }
         741                 :            :
         742                 :          0 :                 PyList_SET_ITEM(fut->fut_callbacks, 0, tup);  /* borrow */
         743                 :            :             }
         744                 :            :         }
         745                 :            :     }
         746                 :            :
         747                 :          0 :     Py_RETURN_NONE;
         748                 :            : }
         749                 :            :
         750                 :            : static PyObject *
         751                 :          0 : future_cancel(asyncio_state *state, FutureObj *fut, PyObject *msg)
         752                 :            : {
         753                 :          0 :     fut->fut_log_tb = 0;
         754                 :            :
         755         [ #  # ]:          0 :     if (fut->fut_state != STATE_PENDING) {
         756                 :          0 :         Py_RETURN_FALSE;
         757                 :            :     }
         758                 :          0 :     fut->fut_state = STATE_CANCELLED;
         759                 :            :
         760                 :          0 :     Py_XINCREF(msg);
         761                 :          0 :     Py_XSETREF(fut->fut_cancel_msg, msg);
         762                 :            :
         763         [ #  # ]:          0 :     if (future_schedule_callbacks(state, fut) == -1) {
         764                 :          0 :         return NULL;
         765                 :            :     }
         766                 :            :
         767                 :          0 :     Py_RETURN_TRUE;
         768                 :            : }
         769                 :            :
         770                 :            : /*[clinic input]
         771                 :            : _asyncio.Future.__init__
         772                 :            :
         773                 :            :     *
         774                 :            :     loop: object = None
         775                 :            :
         776                 :            : This class is *almost* compatible with concurrent.futures.Future.
         777                 :            :
         778                 :            :     Differences:
         779                 :            :
         780                 :            :     - result() and exception() do not take a timeout argument and
         781                 :            :       raise an exception when the future isn't done yet.
         782                 :            :
         783                 :            :     - Callbacks registered with add_done_callback() are always called
         784                 :            :       via the event loop's call_soon_threadsafe().
         785                 :            :
         786                 :            :     - This class is not compatible with the wait() and as_completed()
         787                 :            :       methods in the concurrent.futures package.
         788                 :            : [clinic start generated code]*/
         789                 :            :
         790                 :            : static int
         791                 :          0 : _asyncio_Future___init___impl(FutureObj *self, PyObject *loop)
         792                 :            : /*[clinic end generated code: output=9ed75799eaccb5d6 input=89af317082bc0bf8]*/
         793                 :            :
         794                 :            : {
         795                 :          0 :     return future_init(self, loop);
         796                 :            : }
         797                 :            :
         798                 :            : static int
         799                 :          0 : FutureObj_clear(FutureObj *fut)
         800                 :            : {
         801         [ #  # ]:          0 :     Py_CLEAR(fut->fut_loop);
         802         [ #  # ]:          0 :     Py_CLEAR(fut->fut_callback0);
         803         [ #  # ]:          0 :     Py_CLEAR(fut->fut_context0);
         804         [ #  # ]:          0 :     Py_CLEAR(fut->fut_callbacks);
         805         [ #  # ]:          0 :     Py_CLEAR(fut->fut_result);
         806         [ #  # ]:          0 :     Py_CLEAR(fut->fut_exception);
         807         [ #  # ]:          0 :     Py_CLEAR(fut->fut_exception_tb);
         808         [ #  # ]:          0 :     Py_CLEAR(fut->fut_source_tb);
         809         [ #  # ]:          0 :     Py_CLEAR(fut->fut_cancel_msg);
         810         [ #  # ]:          0 :     Py_CLEAR(fut->fut_cancelled_exc);
         811         [ #  # ]:          0 :     Py_CLEAR(fut->dict);
         812                 :          0 :     return 0;
         813                 :            : }
         814                 :            :
         815                 :            : static int
         816                 :          0 : FutureObj_traverse(FutureObj *fut, visitproc visit, void *arg)
         817                 :            : {
         818   [ #  #  #  # ]:          0 :     Py_VISIT(Py_TYPE(fut));
         819   [ #  #  #  # ]:          0 :     Py_VISIT(fut->fut_loop);
         820   [ #  #  #  # ]:          0 :     Py_VISIT(fut->fut_callback0);
         821   [ #  #  #  # ]:          0 :     Py_VISIT(fut->fut_context0);
         822   [ #  #  #  # ]:          0 :     Py_VISIT(fut->fut_callbacks);
         823   [ #  #  #  # ]:          0 :     Py_VISIT(fut->fut_result);
         824   [ #  #  #  # ]:          0 :     Py_VISIT(fut->fut_exception);
         825   [ #  #  #  # ]:          0 :     Py_VISIT(fut->fut_exception_tb);
         826   [ #  #  #  # ]:          0 :     Py_VISIT(fut->fut_source_tb);
         827   [ #  #  #  # ]:          0 :     Py_VISIT(fut->fut_cancel_msg);
         828   [ #  #  #  # ]:          0 :     Py_VISIT(fut->fut_cancelled_exc);
         829   [ #  #  #  # ]:          0 :     Py_VISIT(fut->dict);
         830                 :          0 :     return 0;
         831                 :            : }
         832                 :            :
         833                 :            : /*[clinic input]
         834                 :            : _asyncio.Future.result
         835                 :            :
         836                 :            : Return the result this future represents.
         837                 :            :
         838                 :            : If the future has been cancelled, raises CancelledError.  If the
         839                 :            : future's result isn't yet available, raises InvalidStateError.  If
         840                 :            : the future is done and has an exception set, this exception is raised.
         841                 :            : [clinic start generated code]*/
         842                 :            :
         843                 :            : static PyObject *
         844                 :          0 : _asyncio_Future_result_impl(FutureObj *self)
         845                 :            : /*[clinic end generated code: output=f35f940936a4b1e5 input=49ecf9cf5ec50dc5]*/
         846                 :            : {
         847                 :          0 :     asyncio_state *state = get_asyncio_state_by_def((PyObject *)self);
         848                 :            :     PyObject *result;
         849                 :            :
         850         [ #  # ]:          0 :     if (!future_is_alive(self)) {
         851                 :          0 :         PyErr_SetString(state->asyncio_InvalidStateError,
         852                 :            :                         "Future object is not initialized.");
         853                 :          0 :         return NULL;
         854                 :            :     }
         855                 :            :
         856                 :          0 :     int res = future_get_result(state, self, &result);
         857                 :            :
         858         [ #  # ]:          0 :     if (res == -1) {
         859                 :          0 :         return NULL;
         860                 :            :     }
         861                 :            :
         862         [ #  # ]:          0 :     if (res == 0) {
         863                 :          0 :         return result;
         864                 :            :     }
         865                 :            :
         866                 :            :     assert(res == 1);
         867                 :            :
         868                 :          0 :     PyErr_SetObject(PyExceptionInstance_Class(result), result);
         869                 :          0 :     Py_DECREF(result);
         870                 :          0 :     return NULL;
         871                 :            : }
         872                 :            :
         873                 :            : /*[clinic input]
         874                 :            : _asyncio.Future.exception
         875                 :            :
         876                 :            :     cls: defining_class
         877                 :            :     /
         878                 :            :
         879                 :            : Return the exception that was set on this future.
         880                 :            :
         881                 :            : The exception (or None if no exception was set) is returned only if
         882                 :            : the future is done.  If the future has been cancelled, raises
         883                 :            : CancelledError.  If the future isn't done yet, raises
         884                 :            : InvalidStateError.
         885                 :            : [clinic start generated code]*/
         886                 :            :
         887                 :            : static PyObject *
         888                 :          0 : _asyncio_Future_exception_impl(FutureObj *self, PyTypeObject *cls)
         889                 :            : /*[clinic end generated code: output=ce75576b187c905b input=3faf15c22acdb60d]*/
         890                 :            : {
         891         [ #  # ]:          0 :     if (!future_is_alive(self)) {
         892                 :          0 :         asyncio_state *state = get_asyncio_state_by_cls(cls);
         893                 :          0 :         PyErr_SetString(state->asyncio_InvalidStateError,
         894                 :            :                         "Future object is not initialized.");
         895                 :          0 :         return NULL;
         896                 :            :     }
         897                 :            :
         898         [ #  # ]:          0 :     if (self->fut_state == STATE_CANCELLED) {
         899                 :          0 :         asyncio_state *state = get_asyncio_state_by_cls(cls);
         900                 :          0 :         future_set_cancelled_error(state, self);
         901                 :          0 :         return NULL;
         902                 :            :     }
         903                 :            :
         904         [ #  # ]:          0 :     if (self->fut_state != STATE_FINISHED) {
         905                 :          0 :         asyncio_state *state = get_asyncio_state_by_cls(cls);
         906                 :          0 :         PyErr_SetString(state->asyncio_InvalidStateError,
         907                 :            :                         "Exception is not set.");
         908                 :          0 :         return NULL;
         909                 :            :     }
         910                 :            :
         911         [ #  # ]:          0 :     if (self->fut_exception != NULL) {
         912                 :          0 :         self->fut_log_tb = 0;
         913                 :          0 :         return Py_NewRef(self->fut_exception);
         914                 :            :     }
         915                 :            :
         916                 :          0 :     Py_RETURN_NONE;
         917                 :            : }
         918                 :            :
         919                 :            : /*[clinic input]
         920                 :            : _asyncio.Future.set_result
         921                 :            :
         922                 :            :     cls: defining_class
         923                 :            :     result: object
         924                 :            :     /
         925                 :            :
         926                 :            : Mark the future done and set its result.
         927                 :            :
         928                 :            : If the future is already done when this method is called, raises
         929                 :            : InvalidStateError.
         930                 :            : [clinic start generated code]*/
         931                 :            :
         932                 :            : static PyObject *
         933                 :          0 : _asyncio_Future_set_result_impl(FutureObj *self, PyTypeObject *cls,
         934                 :            :                                 PyObject *result)
         935                 :            : /*[clinic end generated code: output=99afbbe78f99c32d input=d5a41c1e353acc2e]*/
         936                 :            : {
         937                 :          0 :     asyncio_state *state = get_asyncio_state_by_cls(cls);
         938         [ #  # ]:          0 :     ENSURE_FUTURE_ALIVE(state, self)
         939                 :          0 :     return future_set_result(state, self, result);
         940                 :            : }
         941                 :            :
         942                 :            : /*[clinic input]
         943                 :            : _asyncio.Future.set_exception
         944                 :            :
         945                 :            :     cls: defining_class
         946                 :            :     exception: object
         947                 :            :     /
         948                 :            :
         949                 :            : Mark the future done and set an exception.
         950                 :            :
         951                 :            : If the future is already done when this method is called, raises
         952                 :            : InvalidStateError.
         953                 :            : [clinic start generated code]*/
         954                 :            :
         955                 :            : static PyObject *
         956                 :          0 : _asyncio_Future_set_exception_impl(FutureObj *self, PyTypeObject *cls,
         957                 :            :                                    PyObject *exception)
         958                 :            : /*[clinic end generated code: output=0a5e8b5a52f058d6 input=a245cd49d3df939b]*/
         959                 :            : {
         960                 :          0 :     asyncio_state *state = get_asyncio_state_by_cls(cls);
         961         [ #  # ]:          0 :     ENSURE_FUTURE_ALIVE(state, self)
         962                 :          0 :     return future_set_exception(state, self, exception);
         963                 :            : }
         964                 :            :
         965                 :            : /*[clinic input]
         966                 :            : _asyncio.Future.add_done_callback
         967                 :            :
         968                 :            :     cls: defining_class
         969                 :            :     fn: object
         970                 :            :     /
         971                 :            :     *
         972                 :            :     context: object = NULL
         973                 :            :
         974                 :            : Add a callback to be run when the future becomes done.
         975                 :            :
         976                 :            : The callback is called with a single argument - the future object. If
         977                 :            : the future is already done when this is called, the callback is
         978                 :            : scheduled with call_soon.
         979                 :            : [clinic start generated code]*/
         980                 :            :
         981                 :            : static PyObject *
         982                 :          0 : _asyncio_Future_add_done_callback_impl(FutureObj *self, PyTypeObject *cls,
         983                 :            :                                        PyObject *fn, PyObject *context)
         984                 :            : /*[clinic end generated code: output=922e9a4cbd601167 input=599261c521458cc2]*/
         985                 :            : {
         986                 :          0 :     asyncio_state *state = get_asyncio_state_by_cls(cls);
         987         [ #  # ]:          0 :     if (context == NULL) {
         988                 :          0 :         context = PyContext_CopyCurrent();
         989         [ #  # ]:          0 :         if (context == NULL) {
         990                 :          0 :             return NULL;
         991                 :            :         }
         992                 :          0 :         PyObject *res = future_add_done_callback(state, self, fn, context);
         993                 :          0 :         Py_DECREF(context);
         994                 :          0 :         return res;
         995                 :            :     }
         996                 :          0 :     return future_add_done_callback(state, self, fn, context);
         997                 :            : }
         998                 :            :
         999                 :            : /*[clinic input]
        1000                 :            : _asyncio.Future.remove_done_callback
        1001                 :            :
        1002                 :            :     cls: defining_class
        1003                 :            :     fn: object
        1004                 :            :     /
        1005                 :            :
        1006                 :            : Remove all instances of a callback from the "call when done" list.
        1007                 :            :
        1008                 :            : Returns the number of callbacks removed.
        1009                 :            : [clinic start generated code]*/
        1010                 :            :
        1011                 :            : static PyObject *
        1012                 :          0 : _asyncio_Future_remove_done_callback_impl(FutureObj *self, PyTypeObject *cls,
        1013                 :            :                                           PyObject *fn)
        1014                 :            : /*[clinic end generated code: output=2da35ccabfe41b98 input=c7518709b86fc747]*/
        1015                 :            : {
        1016                 :            :     PyObject *newlist;
        1017                 :          0 :     Py_ssize_t len, i, j=0;
        1018                 :          0 :     Py_ssize_t cleared_callback0 = 0;
        1019                 :            :
        1020                 :          0 :     asyncio_state *state = get_asyncio_state_by_cls(cls);
        1021         [ #  # ]:          0 :     ENSURE_FUTURE_ALIVE(state, self)
        1022                 :            :
        1023         [ #  # ]:          0 :     if (self->fut_callback0 != NULL) {
        1024                 :          0 :         int cmp = PyObject_RichCompareBool(self->fut_callback0, fn, Py_EQ);
        1025         [ #  # ]:          0 :         if (cmp == -1) {
        1026                 :          0 :             return NULL;
        1027                 :            :         }
        1028         [ #  # ]:          0 :         if (cmp == 1) {
        1029                 :            :             /* callback0 == fn */
        1030         [ #  # ]:          0 :             Py_CLEAR(self->fut_callback0);
        1031         [ #  # ]:          0 :             Py_CLEAR(self->fut_context0);
        1032                 :          0 :             cleared_callback0 = 1;
        1033                 :            :         }
        1034                 :            :     }
        1035                 :            :
        1036         [ #  # ]:          0 :     if (self->fut_callbacks == NULL) {
        1037                 :          0 :         return PyLong_FromSsize_t(cleared_callback0);
        1038                 :            :     }
        1039                 :            :
        1040                 :          0 :     len = PyList_GET_SIZE(self->fut_callbacks);
        1041         [ #  # ]:          0 :     if (len == 0) {
        1042         [ #  # ]:          0 :         Py_CLEAR(self->fut_callbacks);
        1043                 :          0 :         return PyLong_FromSsize_t(cleared_callback0);
        1044                 :            :     }
        1045                 :            :
        1046         [ #  # ]:          0 :     if (len == 1) {
        1047                 :          0 :         PyObject *cb_tup = PyList_GET_ITEM(self->fut_callbacks, 0);
        1048                 :          0 :         int cmp = PyObject_RichCompareBool(
        1049                 :            :             PyTuple_GET_ITEM(cb_tup, 0), fn, Py_EQ);
        1050         [ #  # ]:          0 :         if (cmp == -1) {
        1051                 :          0 :             return NULL;
        1052                 :            :         }
        1053         [ #  # ]:          0 :         if (cmp == 1) {
        1054                 :            :             /* callbacks[0] == fn */
        1055         [ #  # ]:          0 :             Py_CLEAR(self->fut_callbacks);
        1056                 :          0 :             return PyLong_FromSsize_t(1 + cleared_callback0);
        1057                 :            :         }
        1058                 :            :         /* callbacks[0] != fn and len(callbacks) == 1 */
        1059                 :          0 :         return PyLong_FromSsize_t(cleared_callback0);
        1060                 :            :     }
        1061                 :            :
        1062                 :          0 :     newlist = PyList_New(len);
        1063         [ #  # ]:          0 :     if (newlist == NULL) {
        1064                 :          0 :         return NULL;
        1065                 :            :     }
        1066                 :            :
        1067                 :            :     // Beware: PyObject_RichCompareBool below may change fut_callbacks.
        1068                 :            :     // See GH-97592.
        1069                 :          0 :     for (i = 0;
        1070   [ #  #  #  # ]:          0 :          self->fut_callbacks != NULL && i < PyList_GET_SIZE(self->fut_callbacks);
        1071                 :          0 :          i++) {
        1072                 :            :         int ret;
        1073                 :          0 :         PyObject *item = PyList_GET_ITEM(self->fut_callbacks, i);
        1074                 :          0 :         Py_INCREF(item);
        1075                 :          0 :         ret = PyObject_RichCompareBool(PyTuple_GET_ITEM(item, 0), fn, Py_EQ);
        1076         [ #  # ]:          0 :         if (ret == 0) {
        1077         [ #  # ]:          0 :             if (j < len) {
        1078                 :          0 :                 PyList_SET_ITEM(newlist, j, item);
        1079                 :          0 :                 j++;
        1080                 :          0 :                 continue;
        1081                 :            :             }
        1082                 :          0 :             ret = PyList_Append(newlist, item);
        1083                 :            :         }
        1084                 :          0 :         Py_DECREF(item);
        1085         [ #  # ]:          0 :         if (ret < 0) {
        1086                 :          0 :             goto fail;
        1087                 :            :         }
        1088                 :            :     }
        1089                 :            :
        1090                 :            :     // Note: fut_callbacks may have been cleared.
        1091   [ #  #  #  # ]:          0 :     if (j == 0 || self->fut_callbacks == NULL) {
        1092         [ #  # ]:          0 :         Py_CLEAR(self->fut_callbacks);
        1093                 :          0 :         Py_DECREF(newlist);
        1094                 :          0 :         return PyLong_FromSsize_t(len + cleared_callback0);
        1095                 :            :     }
        1096                 :            :
        1097         [ #  # ]:          0 :     if (j < len) {
        1098                 :          0 :         Py_SET_SIZE(newlist, j);
        1099                 :            :     }
        1100                 :          0 :     j = PyList_GET_SIZE(newlist);
        1101                 :          0 :     len = PyList_GET_SIZE(self->fut_callbacks);
        1102         [ #  # ]:          0 :     if (j != len) {
        1103         [ #  # ]:          0 :         if (PyList_SetSlice(self->fut_callbacks, 0, len, newlist) < 0) {
        1104                 :          0 :             goto fail;
        1105                 :            :         }
        1106                 :            :     }
        1107                 :          0 :     Py_DECREF(newlist);
        1108                 :          0 :     return PyLong_FromSsize_t(len - j + cleared_callback0);
        1109                 :            :
        1110                 :          0 : fail:
        1111                 :          0 :     Py_DECREF(newlist);
        1112                 :          0 :     return NULL;
        1113                 :            : }
        1114                 :            :
        1115                 :            : /*[clinic input]
        1116                 :            : _asyncio.Future.cancel
        1117                 :            :
        1118                 :            :     cls: defining_class
        1119                 :            :     /
        1120                 :            :     msg: object = None
        1121                 :            :
        1122                 :            : Cancel the future and schedule callbacks.
        1123                 :            :
        1124                 :            : If the future is already done or cancelled, return False.  Otherwise,
        1125                 :            : change the future's state to cancelled, schedule the callbacks and
        1126                 :            : return True.
        1127                 :            : [clinic start generated code]*/
        1128                 :            :
        1129                 :            : static PyObject *
        1130                 :          0 : _asyncio_Future_cancel_impl(FutureObj *self, PyTypeObject *cls,
        1131                 :            :                             PyObject *msg)
        1132                 :            : /*[clinic end generated code: output=074956f35904b034 input=bba8f8b786941a94]*/
        1133                 :            : {
        1134                 :          0 :     asyncio_state *state = get_asyncio_state_by_cls(cls);
        1135         [ #  # ]:          0 :     ENSURE_FUTURE_ALIVE(state, self)
        1136                 :          0 :     return future_cancel(state, self, msg);
        1137                 :            : }
        1138                 :            :
        1139                 :            : /*[clinic input]
        1140                 :            : _asyncio.Future.cancelled
        1141                 :            :
        1142                 :            : Return True if the future was cancelled.
        1143                 :            : [clinic start generated code]*/
        1144                 :            :
        1145                 :            : static PyObject *
        1146                 :          0 : _asyncio_Future_cancelled_impl(FutureObj *self)
        1147                 :            : /*[clinic end generated code: output=145197ced586357d input=943ab8b7b7b17e45]*/
        1148                 :            : {
        1149   [ #  #  #  # ]:          0 :     if (future_is_alive(self) && self->fut_state == STATE_CANCELLED) {
        1150                 :          0 :         Py_RETURN_TRUE;
        1151                 :            :     }
        1152                 :            :     else {
        1153                 :          0 :         Py_RETURN_FALSE;
        1154                 :            :     }
        1155                 :            : }
        1156                 :            :
        1157                 :            : /*[clinic input]
        1158                 :            : _asyncio.Future.done
        1159                 :            :
        1160                 :            : Return True if the future is done.
        1161                 :            :
        1162                 :            : Done means either that a result / exception are available, or that the
        1163                 :            : future was cancelled.
        1164                 :            : [clinic start generated code]*/
        1165                 :            :
        1166                 :            : static PyObject *
        1167                 :          0 : _asyncio_Future_done_impl(FutureObj *self)
        1168                 :            : /*[clinic end generated code: output=244c5ac351145096 input=28d7b23fdb65d2ac]*/
        1169                 :            : {
        1170   [ #  #  #  # ]:          0 :     if (!future_is_alive(self) || self->fut_state == STATE_PENDING) {
        1171                 :          0 :         Py_RETURN_FALSE;
        1172                 :            :     }
        1173                 :            :     else {
        1174                 :          0 :         Py_RETURN_TRUE;
        1175                 :            :     }
        1176                 :            : }
        1177                 :            :
        1178                 :            : /*[clinic input]
        1179                 :            : _asyncio.Future.get_loop
        1180                 :            :
        1181                 :            :     cls: defining_class
        1182                 :            :     /
        1183                 :            :
        1184                 :            : Return the event loop the Future is bound to.
        1185                 :            : [clinic start generated code]*/
        1186                 :            :
        1187                 :            : static PyObject *
        1188                 :          0 : _asyncio_Future_get_loop_impl(FutureObj *self, PyTypeObject *cls)
        1189                 :            : /*[clinic end generated code: output=f50ea6c374d9ee97 input=163c2c498b45a1f0]*/
        1190                 :            : {
        1191                 :          0 :     asyncio_state *state = get_asyncio_state_by_cls(cls);
        1192         [ #  # ]:          0 :     ENSURE_FUTURE_ALIVE(state, self)
        1193                 :          0 :     return Py_NewRef(self->fut_loop);
        1194                 :            : }
        1195                 :            :
        1196                 :            : static PyObject *
        1197                 :          0 : FutureObj_get_blocking(FutureObj *fut, void *Py_UNUSED(ignored))
        1198                 :            : {
        1199   [ #  #  #  # ]:          0 :     if (future_is_alive(fut) && fut->fut_blocking) {
        1200                 :          0 :         Py_RETURN_TRUE;
        1201                 :            :     }
        1202                 :            :     else {
        1203                 :          0 :         Py_RETURN_FALSE;
        1204                 :            :     }
        1205                 :            : }
        1206                 :            :
        1207                 :            : static int
        1208                 :          0 : FutureObj_set_blocking(FutureObj *fut, PyObject *val, void *Py_UNUSED(ignored))
        1209                 :            : {
        1210         [ #  # ]:          0 :     if (future_ensure_alive(fut)) {
        1211                 :          0 :         return -1;
        1212                 :            :     }
        1213         [ #  # ]:          0 :     if (val == NULL) {
        1214                 :          0 :         PyErr_SetString(PyExc_AttributeError, "cannot delete attribute");
        1215                 :          0 :         return -1;
        1216                 :            :     }
        1217                 :            :
        1218                 :          0 :     int is_true = PyObject_IsTrue(val);
        1219         [ #  # ]:          0 :     if (is_true < 0) {
        1220                 :          0 :         return -1;
        1221                 :            :     }
        1222                 :          0 :     fut->fut_blocking = is_true;
        1223                 :          0 :     return 0;
        1224                 :            : }
        1225                 :            :
        1226                 :            : static PyObject *
        1227                 :          0 : FutureObj_get_log_traceback(FutureObj *fut, void *Py_UNUSED(ignored))
        1228                 :            : {
        1229                 :          0 :     asyncio_state *state = get_asyncio_state_by_def((PyObject *)fut);
        1230         [ #  # ]:          0 :     ENSURE_FUTURE_ALIVE(state, fut)
        1231         [ #  # ]:          0 :     if (fut->fut_log_tb) {
        1232                 :          0 :         Py_RETURN_TRUE;
        1233                 :            :     }
        1234                 :            :     else {
        1235                 :          0 :         Py_RETURN_FALSE;
        1236                 :            :     }
        1237                 :            : }
        1238                 :            :
        1239                 :            : static int
        1240                 :          0 : FutureObj_set_log_traceback(FutureObj *fut, PyObject *val, void *Py_UNUSED(ignored))
        1241                 :            : {
        1242         [ #  # ]:          0 :     if (val == NULL) {
        1243                 :          0 :         PyErr_SetString(PyExc_AttributeError, "cannot delete attribute");
        1244                 :          0 :         return -1;
        1245                 :            :     }
        1246                 :          0 :     int is_true = PyObject_IsTrue(val);
        1247         [ #  # ]:          0 :     if (is_true < 0) {
        1248                 :          0 :         return -1;
        1249                 :            :     }
        1250         [ #  # ]:          0 :     if (is_true) {
        1251                 :          0 :         PyErr_SetString(PyExc_ValueError,
        1252                 :            :                         "_log_traceback can only be set to False");
        1253                 :          0 :         return -1;
        1254                 :            :     }
        1255                 :          0 :     fut->fut_log_tb = is_true;
        1256                 :          0 :     return 0;
        1257                 :            : }
        1258                 :            :
        1259                 :            : static PyObject *
        1260                 :          0 : FutureObj_get_loop(FutureObj *fut, void *Py_UNUSED(ignored))
        1261                 :            : {
        1262         [ #  # ]:          0 :     if (!future_is_alive(fut)) {
        1263                 :          0 :         Py_RETURN_NONE;
        1264                 :            :     }
        1265                 :          0 :     return Py_NewRef(fut->fut_loop);
        1266                 :            : }
        1267                 :            :
        1268                 :            : static PyObject *
        1269                 :          0 : FutureObj_get_callbacks(FutureObj *fut, void *Py_UNUSED(ignored))
        1270                 :            : {
        1271                 :          0 :     asyncio_state *state = get_asyncio_state_by_def((PyObject *)fut);
        1272                 :            :     Py_ssize_t i;
        1273                 :            :
        1274         [ #  # ]:          0 :     ENSURE_FUTURE_ALIVE(state, fut)
        1275                 :            :
        1276         [ #  # ]:          0 :     if (fut->fut_callback0 == NULL) {
        1277         [ #  # ]:          0 :         if (fut->fut_callbacks == NULL) {
        1278                 :          0 :             Py_RETURN_NONE;
        1279                 :            :         }
        1280                 :            :
        1281                 :          0 :         return Py_NewRef(fut->fut_callbacks);
        1282                 :            :     }
        1283                 :            :
        1284                 :          0 :     Py_ssize_t len = 1;
        1285         [ #  # ]:          0 :     if (fut->fut_callbacks != NULL) {
        1286                 :          0 :         len += PyList_GET_SIZE(fut->fut_callbacks);
        1287                 :            :     }
        1288                 :            :
        1289                 :            :
        1290                 :          0 :     PyObject *new_list = PyList_New(len);
        1291         [ #  # ]:          0 :     if (new_list == NULL) {
        1292                 :          0 :         return NULL;
        1293                 :            :     }
        1294                 :            :
        1295                 :          0 :     PyObject *tup0 = PyTuple_New(2);
        1296         [ #  # ]:          0 :     if (tup0 == NULL) {
        1297                 :          0 :         Py_DECREF(new_list);
        1298                 :          0 :         return NULL;
        1299                 :            :     }
        1300                 :            :
        1301                 :          0 :     Py_INCREF(fut->fut_callback0);
        1302                 :          0 :     PyTuple_SET_ITEM(tup0, 0, fut->fut_callback0);
        1303                 :            :     assert(fut->fut_context0 != NULL);
        1304                 :          0 :     Py_INCREF(fut->fut_context0);
        1305                 :          0 :     PyTuple_SET_ITEM(tup0, 1, (PyObject *)fut->fut_context0);
        1306                 :            :
        1307                 :          0 :     PyList_SET_ITEM(new_list, 0, tup0);
        1308                 :            :
        1309         [ #  # ]:          0 :     if (fut->fut_callbacks != NULL) {
        1310         [ #  # ]:          0 :         for (i = 0; i < PyList_GET_SIZE(fut->fut_callbacks); i++) {
        1311                 :          0 :             PyObject *cb = PyList_GET_ITEM(fut->fut_callbacks, i);
        1312                 :          0 :             Py_INCREF(cb);
        1313                 :          0 :             PyList_SET_ITEM(new_list, i + 1, cb);
        1314                 :            :         }
        1315                 :            :     }
        1316                 :            :
        1317                 :          0 :     return new_list;
        1318                 :            : }
        1319                 :            :
        1320                 :            : static PyObject *
        1321                 :          0 : FutureObj_get_result(FutureObj *fut, void *Py_UNUSED(ignored))
        1322                 :            : {
        1323                 :          0 :     asyncio_state *state = get_asyncio_state_by_def((PyObject *)fut);
        1324         [ #  # ]:          0 :     ENSURE_FUTURE_ALIVE(state, fut)
        1325         [ #  # ]:          0 :     if (fut->fut_result == NULL) {
        1326                 :          0 :         Py_RETURN_NONE;
        1327                 :            :     }
        1328                 :          0 :     return Py_NewRef(fut->fut_result);
        1329                 :            : }
        1330                 :            :
        1331                 :            : static PyObject *
        1332                 :          0 : FutureObj_get_exception(FutureObj *fut, void *Py_UNUSED(ignored))
        1333                 :            : {
        1334                 :          0 :     asyncio_state *state = get_asyncio_state_by_def((PyObject *)fut);
        1335         [ #  # ]:          0 :     ENSURE_FUTURE_ALIVE(state, fut)
        1336         [ #  # ]:          0 :     if (fut->fut_exception == NULL) {
        1337                 :          0 :         Py_RETURN_NONE;
        1338                 :            :     }
        1339                 :          0 :     return Py_NewRef(fut->fut_exception);
        1340                 :            : }
        1341                 :            :
        1342                 :            : static PyObject *
        1343                 :          0 : FutureObj_get_source_traceback(FutureObj *fut, void *Py_UNUSED(ignored))
        1344                 :            : {
        1345   [ #  #  #  # ]:          0 :     if (!future_is_alive(fut) || fut->fut_source_tb == NULL) {
        1346                 :          0 :         Py_RETURN_NONE;
        1347                 :            :     }
        1348                 :          0 :     return Py_NewRef(fut->fut_source_tb);
        1349                 :            : }
        1350                 :            :
        1351                 :            : static PyObject *
        1352                 :          0 : FutureObj_get_cancel_message(FutureObj *fut, void *Py_UNUSED(ignored))
        1353                 :            : {
        1354         [ #  # ]:          0 :     if (fut->fut_cancel_msg == NULL) {
        1355                 :          0 :         Py_RETURN_NONE;
        1356                 :            :     }
        1357                 :          0 :     return Py_NewRef(fut->fut_cancel_msg);
        1358                 :            : }
        1359                 :            :
        1360                 :            : static int
        1361                 :          0 : FutureObj_set_cancel_message(FutureObj *fut, PyObject *msg,
        1362                 :            :                              void *Py_UNUSED(ignored))
        1363                 :            : {
        1364         [ #  # ]:          0 :     if (msg == NULL) {
        1365                 :          0 :         PyErr_SetString(PyExc_AttributeError, "cannot delete attribute");
        1366                 :          0 :         return -1;
        1367                 :            :     }
        1368                 :          0 :     Py_INCREF(msg);
        1369                 :          0 :     Py_XSETREF(fut->fut_cancel_msg, msg);
        1370                 :          0 :     return 0;
        1371                 :            : }
        1372                 :            :
        1373                 :            : static PyObject *
        1374                 :          0 : FutureObj_get_state(FutureObj *fut, void *Py_UNUSED(ignored))
        1375                 :            : {
        1376                 :          0 :     asyncio_state *state = get_asyncio_state_by_def((PyObject *)fut);
        1377                 :          0 :     PyObject *ret = NULL;
        1378                 :            :
        1379         [ #  # ]:          0 :     ENSURE_FUTURE_ALIVE(state, fut)
        1380                 :            :
        1381   [ #  #  #  # ]:          0 :     switch (fut->fut_state) {
        1382                 :          0 :     case STATE_PENDING:
        1383                 :          0 :         ret = &_Py_ID(PENDING);
        1384                 :          0 :         break;
        1385                 :          0 :     case STATE_CANCELLED:
        1386                 :          0 :         ret = &_Py_ID(CANCELLED);
        1387                 :          0 :         break;
        1388                 :          0 :     case STATE_FINISHED:
        1389                 :          0 :         ret = &_Py_ID(FINISHED);
        1390                 :          0 :         break;
        1391                 :          0 :     default:
        1392                 :            :         assert (0);
        1393                 :            :     }
        1394                 :          0 :     return Py_XNewRef(ret);
        1395                 :            : }
        1396                 :            :
        1397                 :            : static PyObject *
        1398                 :          0 : FutureObj_repr(FutureObj *fut)
        1399                 :            : {
        1400                 :          0 :     asyncio_state *state = get_asyncio_state_by_def((PyObject *)fut);
        1401         [ #  # ]:          0 :     ENSURE_FUTURE_ALIVE(state, fut)
        1402                 :          0 :     return PyObject_CallOneArg(state->asyncio_future_repr_func, (PyObject *)fut);
        1403                 :            : }
        1404                 :            :
        1405                 :            : /*[clinic input]
        1406                 :            : _asyncio.Future._make_cancelled_error
        1407                 :            :
        1408                 :            : Create the CancelledError to raise if the Future is cancelled.
        1409                 :            :
        1410                 :            : This should only be called once when handling a cancellation since
        1411                 :            : it erases the context exception value.
        1412                 :            : [clinic start generated code]*/
        1413                 :            :
        1414                 :            : static PyObject *
        1415                 :          0 : _asyncio_Future__make_cancelled_error_impl(FutureObj *self)
        1416                 :            : /*[clinic end generated code: output=a5df276f6c1213de input=ac6effe4ba795ecc]*/
        1417                 :            : {
        1418                 :          0 :     asyncio_state *state = get_asyncio_state_by_def((PyObject *)self);
        1419                 :          0 :     return create_cancelled_error(state, self);
        1420                 :            : }
        1421                 :            :
        1422                 :            : static void
        1423                 :          0 : FutureObj_finalize(FutureObj *fut)
        1424                 :            : {
        1425                 :            :     PyObject *context;
        1426                 :          0 :     PyObject *message = NULL;
        1427                 :            :     PyObject *func;
        1428                 :            :
        1429         [ #  # ]:          0 :     if (!fut->fut_log_tb) {
        1430                 :          0 :         return;
        1431                 :            :     }
        1432                 :            :     assert(fut->fut_exception != NULL);
        1433                 :          0 :     fut->fut_log_tb = 0;
        1434                 :            :
        1435                 :            :     /* Save the current exception, if any. */
        1436                 :          0 :     PyObject *exc = PyErr_GetRaisedException();
        1437                 :            :
        1438                 :          0 :     context = PyDict_New();
        1439         [ #  # ]:          0 :     if (context == NULL) {
        1440                 :          0 :         goto finally;
        1441                 :            :     }
        1442                 :            :
        1443                 :          0 :     message = PyUnicode_FromFormat(
        1444                 :            :         "%s exception was never retrieved", _PyType_Name(Py_TYPE(fut)));
        1445         [ #  # ]:          0 :     if (message == NULL) {
        1446                 :          0 :         goto finally;
        1447                 :            :     }
        1448                 :            :
        1449   [ #  #  #  # ]:          0 :     if (PyDict_SetItem(context, &_Py_ID(message), message) < 0 ||
        1450         [ #  # ]:          0 :         PyDict_SetItem(context, &_Py_ID(exception), fut->fut_exception) < 0 ||
        1451                 :          0 :         PyDict_SetItem(context, &_Py_ID(future), (PyObject*)fut) < 0) {
        1452                 :          0 :         goto finally;
        1453                 :            :     }
        1454         [ #  # ]:          0 :     if (fut->fut_source_tb != NULL) {
        1455         [ #  # ]:          0 :         if (PyDict_SetItem(context, &_Py_ID(source_traceback),
        1456                 :            :                               fut->fut_source_tb) < 0) {
        1457                 :          0 :             goto finally;
        1458                 :            :         }
        1459                 :            :     }
        1460                 :            :
        1461                 :          0 :     func = PyObject_GetAttr(fut->fut_loop, &_Py_ID(call_exception_handler));
        1462         [ #  # ]:          0 :     if (func != NULL) {
        1463                 :          0 :         PyObject *res = PyObject_CallOneArg(func, context);
        1464         [ #  # ]:          0 :         if (res == NULL) {
        1465                 :          0 :             PyErr_WriteUnraisable(func);
        1466                 :            :         }
        1467                 :            :         else {
        1468                 :          0 :             Py_DECREF(res);
        1469                 :            :         }
        1470                 :          0 :         Py_DECREF(func);
        1471                 :            :     }
        1472                 :            :
        1473                 :          0 : finally:
        1474                 :          0 :     Py_XDECREF(context);
        1475                 :          0 :     Py_XDECREF(message);
        1476                 :            :
        1477                 :            :     /* Restore the saved exception. */
        1478                 :          0 :     PyErr_SetRaisedException(exc);
        1479                 :            : }
        1480                 :            :
        1481                 :            : static PyMethodDef FutureType_methods[] = {
        1482                 :            :     _ASYNCIO_FUTURE_RESULT_METHODDEF
        1483                 :            :     _ASYNCIO_FUTURE_EXCEPTION_METHODDEF
        1484                 :            :     _ASYNCIO_FUTURE_SET_RESULT_METHODDEF
        1485                 :            :     _ASYNCIO_FUTURE_SET_EXCEPTION_METHODDEF
        1486                 :            :     _ASYNCIO_FUTURE_ADD_DONE_CALLBACK_METHODDEF
        1487                 :            :     _ASYNCIO_FUTURE_REMOVE_DONE_CALLBACK_METHODDEF
        1488                 :            :     _ASYNCIO_FUTURE_CANCEL_METHODDEF
        1489                 :            :     _ASYNCIO_FUTURE_CANCELLED_METHODDEF
        1490                 :            :     _ASYNCIO_FUTURE_DONE_METHODDEF
        1491                 :            :     _ASYNCIO_FUTURE_GET_LOOP_METHODDEF
        1492                 :            :     _ASYNCIO_FUTURE__MAKE_CANCELLED_ERROR_METHODDEF
        1493                 :            :     {"__class_getitem__", Py_GenericAlias, METH_O|METH_CLASS, PyDoc_STR("See PEP 585")},
        1494                 :            :     {NULL, NULL}        /* Sentinel */
        1495                 :            : };
        1496                 :            :
        1497                 :            : static PyMemberDef FutureType_members[] = {
        1498                 :            :     {"__weaklistoffset__", T_PYSSIZET, offsetof(FutureObj, fut_weakreflist), READONLY},
        1499                 :            :     {"__dictoffset__", T_PYSSIZET, offsetof(FutureObj, dict), READONLY},
        1500                 :            :     {NULL},
        1501                 :            : };
        1502                 :            :
        1503                 :            : #define FUTURE_COMMON_GETSETLIST                                              \
        1504                 :            :     {"_state", (getter)FutureObj_get_state, NULL, NULL},                      \
        1505                 :            :     {"_asyncio_future_blocking", (getter)FutureObj_get_blocking,              \
        1506                 :            :                                  (setter)FutureObj_set_blocking, NULL},       \
        1507                 :            :     {"_loop", (getter)FutureObj_get_loop, NULL, NULL},                        \
        1508                 :            :     {"_callbacks", (getter)FutureObj_get_callbacks, NULL, NULL},              \
        1509                 :            :     {"_result", (getter)FutureObj_get_result, NULL, NULL},                    \
        1510                 :            :     {"_exception", (getter)FutureObj_get_exception, NULL, NULL},              \
        1511                 :            :     {"_log_traceback", (getter)FutureObj_get_log_traceback,                   \
        1512                 :            :                        (setter)FutureObj_set_log_traceback, NULL},            \
        1513                 :            :     {"_source_traceback", (getter)FutureObj_get_source_traceback,             \
        1514                 :            :                           NULL, NULL},                                        \
        1515                 :            :     {"_cancel_message", (getter)FutureObj_get_cancel_message,                 \
        1516                 :            :                         (setter)FutureObj_set_cancel_message, NULL},
        1517                 :            :
        1518                 :            : static PyGetSetDef FutureType_getsetlist[] = {
        1519                 :            :     FUTURE_COMMON_GETSETLIST
        1520                 :            :     {NULL} /* Sentinel */
        1521                 :            : };
        1522                 :            :
        1523                 :            : static void FutureObj_dealloc(PyObject *self);
        1524                 :            :
        1525                 :            : static PyType_Slot Future_slots[] = {
        1526                 :            :     {Py_tp_dealloc, FutureObj_dealloc},
        1527                 :            :     {Py_tp_repr, (reprfunc)FutureObj_repr},
        1528                 :            :     {Py_tp_doc, (void *)_asyncio_Future___init____doc__},
        1529                 :            :     {Py_tp_traverse, (traverseproc)FutureObj_traverse},
        1530                 :            :     {Py_tp_clear, (inquiry)FutureObj_clear},
        1531                 :            :     {Py_tp_iter, (getiterfunc)future_new_iter},
        1532                 :            :     {Py_tp_methods, FutureType_methods},
        1533                 :            :     {Py_tp_members, FutureType_members},
        1534                 :            :     {Py_tp_getset, FutureType_getsetlist},
        1535                 :            :     {Py_tp_init, (initproc)_asyncio_Future___init__},
        1536                 :            :     {Py_tp_new, PyType_GenericNew},
        1537                 :            :     {Py_tp_finalize, (destructor)FutureObj_finalize},
        1538                 :            :
        1539                 :            :     // async slots
        1540                 :            :     {Py_am_await, (unaryfunc)future_new_iter},
        1541                 :            :     {0, NULL},
        1542                 :            : };
        1543                 :            :
        1544                 :            : static PyType_Spec Future_spec = {
        1545                 :            :     .name = "_asyncio.Future",
        1546                 :            :     .basicsize = sizeof(FutureObj),
        1547                 :            :     .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE |
        1548                 :            :               Py_TPFLAGS_IMMUTABLETYPE),
        1549                 :            :     .slots = Future_slots,
        1550                 :            : };
        1551                 :            :
        1552                 :            : static void
        1553                 :          0 : FutureObj_dealloc(PyObject *self)
        1554                 :            : {
        1555                 :          0 :     FutureObj *fut = (FutureObj *)self;
        1556                 :            :
        1557         [ #  # ]:          0 :     if (PyObject_CallFinalizerFromDealloc(self) < 0) {
        1558                 :            :         // resurrected.
        1559                 :          0 :         return;
        1560                 :            :     }
        1561                 :            :
        1562                 :          0 :     PyTypeObject *tp = Py_TYPE(fut);
        1563                 :          0 :     PyObject_GC_UnTrack(self);
        1564                 :            :
        1565         [ #  # ]:          0 :     if (fut->fut_weakreflist != NULL) {
        1566                 :          0 :         PyObject_ClearWeakRefs(self);
        1567                 :            :     }
        1568                 :            :
        1569                 :          0 :     (void)FutureObj_clear(fut);
        1570                 :          0 :     tp->tp_free(fut);
        1571                 :          0 :     Py_DECREF(tp);
        1572                 :            : }
        1573                 :            :
        1574                 :            :
        1575                 :            : /*********************** Future Iterator **************************/
        1576                 :            :
        1577                 :            : typedef struct {
        1578                 :            :     PyObject_HEAD
        1579                 :            :     FutureObj *future;
        1580                 :            : } futureiterobject;
        1581                 :            :
        1582                 :            :
        1583                 :            : #define FI_FREELIST_MAXLEN 255
        1584                 :            : static futureiterobject *fi_freelist = NULL;
        1585                 :            : static Py_ssize_t fi_freelist_len = 0;
        1586                 :            :
        1587                 :            :
        1588                 :            : static void
        1589                 :          0 : FutureIter_dealloc(futureiterobject *it)
        1590                 :            : {
        1591                 :          0 :     PyTypeObject *tp = Py_TYPE(it);
        1592                 :          0 :     PyObject_GC_UnTrack(it);
        1593                 :          0 :     tp->tp_clear((PyObject *)it);
        1594                 :            :
        1595         [ #  # ]:          0 :     if (fi_freelist_len < FI_FREELIST_MAXLEN) {
        1596                 :          0 :         fi_freelist_len++;
        1597                 :          0 :         it->future = (FutureObj*) fi_freelist;
        1598                 :          0 :         fi_freelist = it;
        1599                 :            :     }
        1600                 :            :     else {
        1601                 :          0 :         PyObject_GC_Del(it);
        1602                 :          0 :         Py_DECREF(tp);
        1603                 :            :     }
        1604                 :          0 : }
        1605                 :            :
        1606                 :            : static PySendResult
        1607                 :          0 : FutureIter_am_send(futureiterobject *it,
        1608                 :            :                    PyObject *Py_UNUSED(arg),
        1609                 :            :                    PyObject **result)
        1610                 :            : {
        1611                 :            :     /* arg is unused, see the comment on FutureIter_send for clarification */
        1612                 :            :
        1613                 :            :     PyObject *res;
        1614                 :          0 :     FutureObj *fut = it->future;
        1615                 :            :
        1616                 :          0 :     *result = NULL;
        1617         [ #  # ]:          0 :     if (fut == NULL) {
        1618                 :          0 :         return PYGEN_ERROR;
        1619                 :            :     }
        1620                 :            :
        1621         [ #  # ]:          0 :     if (fut->fut_state == STATE_PENDING) {
        1622         [ #  # ]:          0 :         if (!fut->fut_blocking) {
        1623                 :          0 :             fut->fut_blocking = 1;
        1624                 :          0 :             *result = Py_NewRef(fut);
        1625                 :          0 :             return PYGEN_NEXT;
        1626                 :            :         }
        1627                 :          0 :         PyErr_SetString(PyExc_RuntimeError,
        1628                 :            :                         "await wasn't used with future");
        1629                 :          0 :         return PYGEN_ERROR;
        1630                 :            :     }
        1631                 :            :
        1632                 :          0 :     it->future = NULL;
        1633                 :          0 :     res = _asyncio_Future_result_impl(fut);
        1634         [ #  # ]:          0 :     if (res != NULL) {
        1635                 :          0 :         Py_DECREF(fut);
        1636                 :          0 :         *result = res;
        1637                 :          0 :         return PYGEN_RETURN;
        1638                 :            :     }
        1639                 :            :
        1640                 :          0 :     Py_DECREF(fut);
        1641                 :          0 :     return PYGEN_ERROR;
        1642                 :            : }
        1643                 :            :
        1644                 :            : static PyObject *
        1645                 :          0 : FutureIter_iternext(futureiterobject *it)
        1646                 :            : {
        1647                 :            :     PyObject *result;
        1648   [ #  #  #  # ]:          0 :     switch (FutureIter_am_send(it, Py_None, &result)) {
        1649                 :          0 :         case PYGEN_RETURN:
        1650                 :          0 :             (void)_PyGen_SetStopIterationValue(result);
        1651                 :          0 :             Py_DECREF(result);
        1652                 :          0 :             return NULL;
        1653                 :          0 :         case PYGEN_NEXT:
        1654                 :          0 :             return result;
        1655                 :          0 :         case PYGEN_ERROR:
        1656                 :          0 :             return NULL;
        1657                 :          0 :         default:
        1658                 :          0 :             Py_UNREACHABLE();
        1659                 :            :     }
        1660                 :            : }
        1661                 :            :
        1662                 :            : static PyObject *
        1663                 :          0 : FutureIter_send(futureiterobject *self, PyObject *unused)
        1664                 :            : {
        1665                 :            :     /* Future.__iter__ doesn't care about values that are pushed to the
        1666                 :            :      * generator, it just returns self.result().
        1667                 :            :      */
        1668                 :          0 :     return FutureIter_iternext(self);
        1669                 :            : }
        1670                 :            :
        1671                 :            : static PyObject *
        1672                 :          0 : FutureIter_throw(futureiterobject *self, PyObject *const *args, Py_ssize_t nargs)
        1673                 :            : {
        1674                 :          0 :     PyObject *type, *val = NULL, *tb = NULL;
        1675   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("throw", nargs, 1, 3)) {
                       #  # ]
        1676                 :          0 :         return NULL;
        1677                 :            :     }
        1678         [ #  # ]:          0 :     if (nargs > 1) {
        1679         [ #  # ]:          0 :         if (PyErr_WarnEx(PyExc_DeprecationWarning,
        1680                 :            :                             "the (type, exc, tb) signature of throw() is deprecated, "
        1681                 :            :                             "use the single-arg signature instead.",
        1682                 :            :                             1) < 0) {
        1683                 :          0 :             return NULL;
        1684                 :            :         }
        1685                 :            :     }
        1686                 :            :
        1687                 :          0 :     type = args[0];
        1688         [ #  # ]:          0 :     if (nargs == 3) {
        1689                 :          0 :         val = args[1];
        1690                 :          0 :         tb = args[2];
        1691                 :            :     }
        1692         [ #  # ]:          0 :     else if (nargs == 2) {
        1693                 :          0 :         val = args[1];
        1694                 :            :     }
        1695                 :            :
        1696         [ #  # ]:          0 :     if (val == Py_None) {
        1697                 :          0 :         val = NULL;
        1698                 :            :     }
        1699         [ #  # ]:          0 :     if (tb == Py_None ) {
        1700                 :          0 :         tb = NULL;
        1701   [ #  #  #  # ]:          0 :     } else if (tb != NULL && !PyTraceBack_Check(tb)) {
        1702                 :          0 :         PyErr_SetString(PyExc_TypeError, "throw() third argument must be a traceback");
        1703                 :          0 :         return NULL;
        1704                 :            :     }
        1705                 :            :
        1706                 :          0 :     Py_INCREF(type);
        1707                 :          0 :     Py_XINCREF(val);
        1708                 :          0 :     Py_XINCREF(tb);
        1709                 :            :
        1710   [ #  #  #  # ]:          0 :     if (PyExceptionClass_Check(type)) {
        1711                 :          0 :         PyErr_NormalizeException(&type, &val, &tb);
        1712                 :            :         /* No need to call PyException_SetTraceback since we'll be calling
        1713                 :            :            PyErr_Restore for `type`, `val`, and `tb`. */
        1714         [ #  # ]:          0 :     } else if (PyExceptionInstance_Check(type)) {
        1715         [ #  # ]:          0 :         if (val) {
        1716                 :          0 :             PyErr_SetString(PyExc_TypeError,
        1717                 :            :                             "instance exception may not have a separate value");
        1718                 :          0 :             goto fail;
        1719                 :            :         }
        1720                 :          0 :         val = type;
        1721                 :          0 :         type = PyExceptionInstance_Class(type);
        1722                 :          0 :         Py_INCREF(type);
        1723         [ #  # ]:          0 :         if (tb == NULL)
        1724                 :          0 :             tb = PyException_GetTraceback(val);
        1725                 :            :     } else {
        1726                 :          0 :         PyErr_SetString(PyExc_TypeError,
        1727                 :            :                         "exceptions must be classes deriving BaseException or "
        1728                 :            :                         "instances of such a class");
        1729                 :          0 :         goto fail;
        1730                 :            :     }
        1731                 :            :
        1732         [ #  # ]:          0 :     Py_CLEAR(self->future);
        1733                 :            :
        1734                 :          0 :     PyErr_Restore(type, val, tb);
        1735                 :            :
        1736                 :          0 :     return NULL;
        1737                 :            :
        1738                 :          0 :   fail:
        1739                 :          0 :     Py_DECREF(type);
        1740                 :          0 :     Py_XDECREF(val);
        1741                 :          0 :     Py_XDECREF(tb);
        1742                 :          0 :     return NULL;
        1743                 :            : }
        1744                 :            :
        1745                 :            : static int
        1746                 :          0 : FutureIter_clear(futureiterobject *it)
        1747                 :            : {
        1748         [ #  # ]:          0 :     Py_CLEAR(it->future);
        1749                 :          0 :     return 0;
        1750                 :            : }
        1751                 :            :
        1752                 :            : static PyObject *
        1753                 :          0 : FutureIter_close(futureiterobject *self, PyObject *arg)
        1754                 :            : {
        1755                 :          0 :     (void)FutureIter_clear(self);
        1756                 :          0 :     Py_RETURN_NONE;
        1757                 :            : }
        1758                 :            :
        1759                 :            : static int
        1760                 :          0 : FutureIter_traverse(futureiterobject *it, visitproc visit, void *arg)
        1761                 :            : {
        1762   [ #  #  #  # ]:          0 :     Py_VISIT(Py_TYPE(it));
        1763   [ #  #  #  # ]:          0 :     Py_VISIT(it->future);
        1764                 :          0 :     return 0;
        1765                 :            : }
        1766                 :            :
        1767                 :            : static PyMethodDef FutureIter_methods[] = {
        1768                 :            :     {"send",  (PyCFunction)FutureIter_send, METH_O, NULL},
        1769                 :            :     {"throw", _PyCFunction_CAST(FutureIter_throw), METH_FASTCALL, NULL},
        1770                 :            :     {"close", (PyCFunction)FutureIter_close, METH_NOARGS, NULL},
        1771                 :            :     {NULL, NULL}        /* Sentinel */
        1772                 :            : };
        1773                 :            :
        1774                 :            : static PyType_Slot FutureIter_slots[] = {
        1775                 :            :     {Py_tp_dealloc, (destructor)FutureIter_dealloc},
        1776                 :            :     {Py_tp_getattro, PyObject_GenericGetAttr},
        1777                 :            :     {Py_tp_traverse, (traverseproc)FutureIter_traverse},
        1778                 :            :     {Py_tp_clear, FutureIter_clear},
        1779                 :            :     {Py_tp_iter, PyObject_SelfIter},
        1780                 :            :     {Py_tp_iternext, (iternextfunc)FutureIter_iternext},
        1781                 :            :     {Py_tp_methods, FutureIter_methods},
        1782                 :            :
        1783                 :            :     // async methods
        1784                 :            :     {Py_am_send, (sendfunc)FutureIter_am_send},
        1785                 :            :     {0, NULL},
        1786                 :            : };
        1787                 :            :
        1788                 :            : static PyType_Spec FutureIter_spec = {
        1789                 :            :     .name = "_asyncio.FutureIter",
        1790                 :            :     .basicsize = sizeof(futureiterobject),
        1791                 :            :     .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
        1792                 :            :               Py_TPFLAGS_IMMUTABLETYPE),
        1793                 :            :     .slots = FutureIter_slots,
        1794                 :            : };
        1795                 :            :
        1796                 :            : static PyObject *
        1797                 :          0 : future_new_iter(PyObject *fut)
        1798                 :            : {
        1799                 :            :     futureiterobject *it;
        1800                 :            :
        1801                 :          0 :     asyncio_state *state = get_asyncio_state_by_def((PyObject *)fut);
        1802         [ #  # ]:          0 :     if (!Future_Check(state, fut)) {
        1803                 :          0 :         PyErr_BadInternalCall();
        1804                 :          0 :         return NULL;
        1805                 :            :     }
        1806                 :            :
        1807         [ #  # ]:          0 :     ENSURE_FUTURE_ALIVE(state, fut)
        1808                 :            :
        1809         [ #  # ]:          0 :     if (fi_freelist_len) {
        1810                 :          0 :         fi_freelist_len--;
        1811                 :          0 :         it = fi_freelist;
        1812                 :          0 :         fi_freelist = (futureiterobject*) it->future;
        1813                 :          0 :         it->future = NULL;
        1814                 :          0 :         _Py_NewReference((PyObject*) it);
        1815                 :            :     }
        1816                 :            :     else {
        1817                 :          0 :         it = PyObject_GC_New(futureiterobject, state->FutureIterType);
        1818         [ #  # ]:          0 :         if (it == NULL) {
        1819                 :          0 :             return NULL;
        1820                 :            :         }
        1821                 :            :     }
        1822                 :            :
        1823                 :          0 :     it->future = (FutureObj*)Py_NewRef(fut);
        1824                 :          0 :     PyObject_GC_Track(it);
        1825                 :          0 :     return (PyObject*)it;
        1826                 :            : }
        1827                 :            :
        1828                 :            :
        1829                 :            : /*********************** Task **************************/
        1830                 :            :
        1831                 :            :
        1832                 :            : /*[clinic input]
        1833                 :            : class _asyncio.Task "TaskObj *" "&Task_Type"
        1834                 :            : [clinic start generated code]*/
        1835                 :            : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=719dcef0fcc03b37]*/
        1836                 :            :
        1837                 :            : static int task_call_step_soon(asyncio_state *state, TaskObj *, PyObject *);
        1838                 :            : static PyObject * task_wakeup(TaskObj *, PyObject *);
        1839                 :            : static PyObject * task_step(asyncio_state *, TaskObj *, PyObject *);
        1840                 :            :
        1841                 :            : /* ----- Task._step wrapper */
        1842                 :            :
        1843                 :            : static int
        1844                 :          0 : TaskStepMethWrapper_clear(TaskStepMethWrapper *o)
        1845                 :            : {
        1846         [ #  # ]:          0 :     Py_CLEAR(o->sw_task);
        1847         [ #  # ]:          0 :     Py_CLEAR(o->sw_arg);
        1848                 :          0 :     return 0;
        1849                 :            : }
        1850                 :            :
        1851                 :            : static void
        1852                 :          0 : TaskStepMethWrapper_dealloc(TaskStepMethWrapper *o)
        1853                 :            : {
        1854                 :          0 :     PyTypeObject *tp = Py_TYPE(o);
        1855                 :          0 :     PyObject_GC_UnTrack(o);
        1856                 :          0 :     (void)TaskStepMethWrapper_clear(o);
        1857                 :          0 :     Py_TYPE(o)->tp_free(o);
        1858                 :          0 :     Py_DECREF(tp);
        1859                 :          0 : }
        1860                 :            :
        1861                 :            : static PyObject *
        1862                 :          0 : TaskStepMethWrapper_call(TaskStepMethWrapper *o,
        1863                 :            :                          PyObject *args, PyObject *kwds)
        1864                 :            : {
        1865   [ #  #  #  # ]:          0 :     if (kwds != NULL && PyDict_GET_SIZE(kwds) != 0) {
        1866                 :          0 :         PyErr_SetString(PyExc_TypeError, "function takes no keyword arguments");
        1867                 :          0 :         return NULL;
        1868                 :            :     }
        1869   [ #  #  #  # ]:          0 :     if (args != NULL && PyTuple_GET_SIZE(args) != 0) {
        1870                 :          0 :         PyErr_SetString(PyExc_TypeError, "function takes no positional arguments");
        1871                 :          0 :         return NULL;
        1872                 :            :     }
        1873                 :          0 :     asyncio_state *state = get_asyncio_state_by_def((PyObject *)o);
        1874                 :          0 :     return task_step(state, o->sw_task, o->sw_arg);
        1875                 :            : }
        1876                 :            :
        1877                 :            : static int
        1878                 :          0 : TaskStepMethWrapper_traverse(TaskStepMethWrapper *o,
        1879                 :            :                              visitproc visit, void *arg)
        1880                 :            : {
        1881   [ #  #  #  # ]:          0 :     Py_VISIT(Py_TYPE(o));
        1882   [ #  #  #  # ]:          0 :     Py_VISIT(o->sw_task);
        1883   [ #  #  #  # ]:          0 :     Py_VISIT(o->sw_arg);
        1884                 :          0 :     return 0;
        1885                 :            : }
        1886                 :            :
        1887                 :            : static PyObject *
        1888                 :          0 : TaskStepMethWrapper_get___self__(TaskStepMethWrapper *o, void *Py_UNUSED(ignored))
        1889                 :            : {
        1890         [ #  # ]:          0 :     if (o->sw_task) {
        1891                 :          0 :         return Py_NewRef(o->sw_task);
        1892                 :            :     }
        1893                 :          0 :     Py_RETURN_NONE;
        1894                 :            : }
        1895                 :            :
        1896                 :            : static PyGetSetDef TaskStepMethWrapper_getsetlist[] = {
        1897                 :            :     {"__self__", (getter)TaskStepMethWrapper_get___self__, NULL, NULL},
        1898                 :            :     {NULL} /* Sentinel */
        1899                 :            : };
        1900                 :            :
        1901                 :            : static PyType_Slot TaskStepMethWrapper_slots[] = {
        1902                 :            :     {Py_tp_getset, TaskStepMethWrapper_getsetlist},
        1903                 :            :     {Py_tp_dealloc, (destructor)TaskStepMethWrapper_dealloc},
        1904                 :            :     {Py_tp_call, (ternaryfunc)TaskStepMethWrapper_call},
        1905                 :            :     {Py_tp_getattro, PyObject_GenericGetAttr},
        1906                 :            :     {Py_tp_traverse, (traverseproc)TaskStepMethWrapper_traverse},
        1907                 :            :     {Py_tp_clear, (inquiry)TaskStepMethWrapper_clear},
        1908                 :            :     {0, NULL},
        1909                 :            : };
        1910                 :            :
        1911                 :            : static PyType_Spec TaskStepMethWrapper_spec = {
        1912                 :            :     .name = "_asyncio.TaskStepMethWrapper",
        1913                 :            :     .basicsize = sizeof(TaskStepMethWrapper),
        1914                 :            :     .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
        1915                 :            :               Py_TPFLAGS_IMMUTABLETYPE),
        1916                 :            :     .slots = TaskStepMethWrapper_slots,
        1917                 :            : };
        1918                 :            :
        1919                 :            : static PyObject *
        1920                 :          0 : TaskStepMethWrapper_new(TaskObj *task, PyObject *arg)
        1921                 :            : {
        1922                 :          0 :     asyncio_state *state = get_asyncio_state_by_def((PyObject *)task);
        1923                 :            :     TaskStepMethWrapper *o;
        1924                 :          0 :     o = PyObject_GC_New(TaskStepMethWrapper, state->TaskStepMethWrapper_Type);
        1925         [ #  # ]:          0 :     if (o == NULL) {
        1926                 :          0 :         return NULL;
        1927                 :            :     }
        1928                 :            :
        1929                 :          0 :     o->sw_task = (TaskObj*)Py_NewRef(task);
        1930                 :          0 :     o->sw_arg = Py_XNewRef(arg);
        1931                 :            :
        1932                 :          0 :     PyObject_GC_Track(o);
        1933                 :          0 :     return (PyObject*) o;
        1934                 :            : }
        1935                 :            :
        1936                 :            : /* ----- Task._wakeup implementation */
        1937                 :            :
        1938                 :            : static  PyMethodDef TaskWakeupDef = {
        1939                 :            :     "task_wakeup",
        1940                 :            :     (PyCFunction)task_wakeup,
        1941                 :            :     METH_O,
        1942                 :            :     NULL
        1943                 :            : };
        1944                 :            :
        1945                 :            : /* ----- Task introspection helpers */
        1946                 :            :
        1947                 :            : static int
        1948                 :          0 : register_task(asyncio_state *state, PyObject *task)
        1949                 :            : {
        1950                 :          0 :     PyObject *res = PyObject_CallMethodOneArg(state->all_tasks,
        1951                 :            :                                                  &_Py_ID(add), task);
        1952         [ #  # ]:          0 :     if (res == NULL) {
        1953                 :          0 :         return -1;
        1954                 :            :     }
        1955                 :          0 :     Py_DECREF(res);
        1956                 :          0 :     return 0;
        1957                 :            : }
        1958                 :            :
        1959                 :            :
        1960                 :            : static int
        1961                 :          0 : unregister_task(asyncio_state *state, PyObject *task)
        1962                 :            : {
        1963                 :          0 :     PyObject *res = PyObject_CallMethodOneArg(state->all_tasks,
        1964                 :            :                                      &_Py_ID(discard), task);
        1965         [ #  # ]:          0 :     if (res == NULL) {
        1966                 :          0 :         return -1;
        1967                 :            :     }
        1968                 :          0 :     Py_DECREF(res);
        1969                 :          0 :     return 0;
        1970                 :            : }
        1971                 :            :
        1972                 :            :
        1973                 :            : static int
        1974                 :          0 : enter_task(asyncio_state *state, PyObject *loop, PyObject *task)
        1975                 :            : {
        1976                 :            :     PyObject *item;
        1977                 :            :     Py_hash_t hash;
        1978                 :          0 :     hash = PyObject_Hash(loop);
        1979         [ #  # ]:          0 :     if (hash == -1) {
        1980                 :          0 :         return -1;
        1981                 :            :     }
        1982                 :          0 :     item = _PyDict_GetItem_KnownHash(state->current_tasks, loop, hash);
        1983         [ #  # ]:          0 :     if (item != NULL) {
        1984                 :          0 :         Py_INCREF(item);
        1985                 :          0 :         PyErr_Format(
        1986                 :            :             PyExc_RuntimeError,
        1987                 :            :             "Cannot enter into task %R while another " \
        1988                 :            :             "task %R is being executed.",
        1989                 :            :             task, item, NULL);
        1990                 :          0 :         Py_DECREF(item);
        1991                 :          0 :         return -1;
        1992                 :            :     }
        1993         [ #  # ]:          0 :     if (PyErr_Occurred()) {
        1994                 :          0 :         return -1;
        1995                 :            :     }
        1996                 :          0 :     return _PyDict_SetItem_KnownHash(state->current_tasks, loop, task, hash);
        1997                 :            : }
        1998                 :            :
        1999                 :            :
        2000                 :            : static int
        2001                 :          0 : leave_task(asyncio_state *state, PyObject *loop, PyObject *task)
        2002                 :            : /*[clinic end generated code: output=0ebf6db4b858fb41 input=51296a46313d1ad8]*/
        2003                 :            : {
        2004                 :            :     PyObject *item;
        2005                 :            :     Py_hash_t hash;
        2006                 :          0 :     hash = PyObject_Hash(loop);
        2007         [ #  # ]:          0 :     if (hash == -1) {
        2008                 :          0 :         return -1;
        2009                 :            :     }
        2010                 :          0 :     item = _PyDict_GetItem_KnownHash(state->current_tasks, loop, hash);
        2011         [ #  # ]:          0 :     if (item != task) {
        2012         [ #  # ]:          0 :         if (item == NULL) {
        2013                 :            :             /* Not entered, replace with None */
        2014                 :          0 :             item = Py_None;
        2015                 :            :         }
        2016                 :          0 :         PyErr_Format(
        2017                 :            :             PyExc_RuntimeError,
        2018                 :            :             "Leaving task %R does not match the current task %R.",
        2019                 :            :             task, item, NULL);
        2020                 :          0 :         return -1;
        2021                 :            :     }
        2022                 :          0 :     return _PyDict_DelItem_KnownHash(state->current_tasks, loop, hash);
        2023                 :            : }
        2024                 :            :
        2025                 :            : /* ----- Task */
        2026                 :            :
        2027                 :            : /*[clinic input]
        2028                 :            : _asyncio.Task.__init__
        2029                 :            :
        2030                 :            :     coro: object
        2031                 :            :     *
        2032                 :            :     loop: object = None
        2033                 :            :     name: object = None
        2034                 :            :     context: object = None
        2035                 :            :
        2036                 :            : A coroutine wrapped in a Future.
        2037                 :            : [clinic start generated code]*/
        2038                 :            :
        2039                 :            : static int
        2040                 :          0 : _asyncio_Task___init___impl(TaskObj *self, PyObject *coro, PyObject *loop,
        2041                 :            :                             PyObject *name, PyObject *context)
        2042                 :            : /*[clinic end generated code: output=49ac96fe33d0e5c7 input=924522490c8ce825]*/
        2043                 :            :
        2044                 :            : {
        2045         [ #  # ]:          0 :     if (future_init((FutureObj*)self, loop)) {
        2046                 :          0 :         return -1;
        2047                 :            :     }
        2048                 :            :
        2049                 :          0 :     asyncio_state *state = get_asyncio_state_by_def((PyObject *)self);
        2050                 :          0 :     int is_coro = is_coroutine(state, coro);
        2051         [ #  # ]:          0 :     if (is_coro == -1) {
        2052                 :          0 :         return -1;
        2053                 :            :     }
        2054         [ #  # ]:          0 :     if (is_coro == 0) {
        2055                 :          0 :         self->task_log_destroy_pending = 0;
        2056                 :          0 :         PyErr_Format(PyExc_TypeError,
        2057                 :            :                      "a coroutine was expected, got %R",
        2058                 :            :                      coro, NULL);
        2059                 :          0 :         return -1;
        2060                 :            :     }
        2061                 :            :
        2062         [ #  # ]:          0 :     if (context == Py_None) {
        2063                 :          0 :         Py_XSETREF(self->task_context, PyContext_CopyCurrent());
        2064         [ #  # ]:          0 :         if (self->task_context == NULL) {
        2065                 :          0 :             return -1;
        2066                 :            :         }
        2067                 :            :     } else {
        2068                 :          0 :         self->task_context = Py_NewRef(context);
        2069                 :            :     }
        2070                 :            :
        2071         [ #  # ]:          0 :     Py_CLEAR(self->task_fut_waiter);
        2072                 :          0 :     self->task_must_cancel = 0;
        2073                 :          0 :     self->task_log_destroy_pending = 1;
        2074                 :          0 :     self->task_num_cancels_requested = 0;
        2075                 :          0 :     Py_INCREF(coro);
        2076                 :          0 :     Py_XSETREF(self->task_coro, coro);
        2077                 :            :
        2078         [ #  # ]:          0 :     if (name == Py_None) {
        2079                 :          0 :         name = PyUnicode_FromFormat("Task-%" PRIu64,
        2080                 :          0 :                                     ++state->task_name_counter);
        2081         [ #  # ]:          0 :     } else if (!PyUnicode_CheckExact(name)) {
        2082                 :          0 :         name = PyObject_Str(name);
        2083                 :            :     } else {
        2084                 :          0 :         Py_INCREF(name);
        2085                 :            :     }
        2086                 :          0 :     Py_XSETREF(self->task_name, name);
        2087         [ #  # ]:          0 :     if (self->task_name == NULL) {
        2088                 :          0 :         return -1;
        2089                 :            :     }
        2090                 :            :
        2091         [ #  # ]:          0 :     if (task_call_step_soon(state, self, NULL)) {
        2092                 :          0 :         return -1;
        2093                 :            :     }
        2094                 :          0 :     return register_task(state, (PyObject*)self);
        2095                 :            : }
        2096                 :            :
        2097                 :            : static int
        2098                 :          0 : TaskObj_clear(TaskObj *task)
        2099                 :            : {
        2100                 :          0 :     (void)FutureObj_clear((FutureObj*) task);
        2101         [ #  # ]:          0 :     Py_CLEAR(task->task_context);
        2102         [ #  # ]:          0 :     Py_CLEAR(task->task_coro);
        2103         [ #  # ]:          0 :     Py_CLEAR(task->task_name);
        2104         [ #  # ]:          0 :     Py_CLEAR(task->task_fut_waiter);
        2105                 :          0 :     return 0;
        2106                 :            : }
        2107                 :            :
        2108                 :            : static int
        2109                 :          0 : TaskObj_traverse(TaskObj *task, visitproc visit, void *arg)
        2110                 :            : {
        2111   [ #  #  #  # ]:          0 :     Py_VISIT(Py_TYPE(task));
        2112   [ #  #  #  # ]:          0 :     Py_VISIT(task->task_context);
        2113   [ #  #  #  # ]:          0 :     Py_VISIT(task->task_coro);
        2114   [ #  #  #  # ]:          0 :     Py_VISIT(task->task_name);
        2115   [ #  #  #  # ]:          0 :     Py_VISIT(task->task_fut_waiter);
        2116                 :          0 :     FutureObj *fut = (FutureObj *)task;
        2117   [ #  #  #  # ]:          0 :     Py_VISIT(fut->fut_loop);
        2118   [ #  #  #  # ]:          0 :     Py_VISIT(fut->fut_callback0);
        2119   [ #  #  #  # ]:          0 :     Py_VISIT(fut->fut_context0);
        2120   [ #  #  #  # ]:          0 :     Py_VISIT(fut->fut_callbacks);
        2121   [ #  #  #  # ]:          0 :     Py_VISIT(fut->fut_result);
        2122   [ #  #  #  # ]:          0 :     Py_VISIT(fut->fut_exception);
        2123   [ #  #  #  # ]:          0 :     Py_VISIT(fut->fut_exception_tb);
        2124   [ #  #  #  # ]:          0 :     Py_VISIT(fut->fut_source_tb);
        2125   [ #  #  #  # ]:          0 :     Py_VISIT(fut->fut_cancel_msg);
        2126   [ #  #  #  # ]:          0 :     Py_VISIT(fut->fut_cancelled_exc);
        2127   [ #  #  #  # ]:          0 :     Py_VISIT(fut->dict);
        2128                 :          0 :     return 0;
        2129                 :            : }
        2130                 :            :
        2131                 :            : static PyObject *
        2132                 :          0 : TaskObj_get_log_destroy_pending(TaskObj *task, void *Py_UNUSED(ignored))
        2133                 :            : {
        2134         [ #  # ]:          0 :     if (task->task_log_destroy_pending) {
        2135                 :          0 :         Py_RETURN_TRUE;
        2136                 :            :     }
        2137                 :            :     else {
        2138                 :          0 :         Py_RETURN_FALSE;
        2139                 :            :     }
        2140                 :            : }
        2141                 :            :
        2142                 :            : static int
        2143                 :          0 : TaskObj_set_log_destroy_pending(TaskObj *task, PyObject *val, void *Py_UNUSED(ignored))
        2144                 :            : {
        2145         [ #  # ]:          0 :     if (val == NULL) {
        2146                 :          0 :         PyErr_SetString(PyExc_AttributeError, "cannot delete attribute");
        2147                 :          0 :         return -1;
        2148                 :            :     }
        2149                 :          0 :     int is_true = PyObject_IsTrue(val);
        2150         [ #  # ]:          0 :     if (is_true < 0) {
        2151                 :          0 :         return -1;
        2152                 :            :     }
        2153                 :          0 :     task->task_log_destroy_pending = is_true;
        2154                 :          0 :     return 0;
        2155                 :            : }
        2156                 :            :
        2157                 :            : static PyObject *
        2158                 :          0 : TaskObj_get_must_cancel(TaskObj *task, void *Py_UNUSED(ignored))
        2159                 :            : {
        2160         [ #  # ]:          0 :     if (task->task_must_cancel) {
        2161                 :          0 :         Py_RETURN_TRUE;
        2162                 :            :     }
        2163                 :            :     else {
        2164                 :          0 :         Py_RETURN_FALSE;
        2165                 :            :     }
        2166                 :            : }
        2167                 :            :
        2168                 :            : static PyObject *
        2169                 :          0 : TaskObj_get_coro(TaskObj *task, void *Py_UNUSED(ignored))
        2170                 :            : {
        2171         [ #  # ]:          0 :     if (task->task_coro) {
        2172                 :          0 :         return Py_NewRef(task->task_coro);
        2173                 :            :     }
        2174                 :            :
        2175                 :          0 :     Py_RETURN_NONE;
        2176                 :            : }
        2177                 :            :
        2178                 :            : static PyObject *
        2179                 :          0 : TaskObj_get_fut_waiter(TaskObj *task, void *Py_UNUSED(ignored))
        2180                 :            : {
        2181         [ #  # ]:          0 :     if (task->task_fut_waiter) {
        2182                 :          0 :         return Py_NewRef(task->task_fut_waiter);
        2183                 :            :     }
        2184                 :            :
        2185                 :          0 :     Py_RETURN_NONE;
        2186                 :            : }
        2187                 :            :
        2188                 :            : static PyObject *
        2189                 :          0 : TaskObj_repr(TaskObj *task)
        2190                 :            : {
        2191                 :          0 :     asyncio_state *state = get_asyncio_state_by_def((PyObject *)task);
        2192                 :          0 :     return PyObject_CallOneArg(state->asyncio_task_repr_func,
        2193                 :            :                                (PyObject *)task);
        2194                 :            : }
        2195                 :            :
        2196                 :            :
        2197                 :            : /*[clinic input]
        2198                 :            : _asyncio.Task._make_cancelled_error
        2199                 :            :
        2200                 :            : Create the CancelledError to raise if the Task is cancelled.
        2201                 :            :
        2202                 :            : This should only be called once when handling a cancellation since
        2203                 :            : it erases the context exception value.
        2204                 :            : [clinic start generated code]*/
        2205                 :            :
        2206                 :            : static PyObject *
        2207                 :          0 : _asyncio_Task__make_cancelled_error_impl(TaskObj *self)
        2208                 :            : /*[clinic end generated code: output=55a819e8b4276fab input=52c0e32de8e2f840]*/
        2209                 :            : {
        2210                 :          0 :     FutureObj *fut = (FutureObj*)self;
        2211                 :          0 :     return _asyncio_Future__make_cancelled_error_impl(fut);
        2212                 :            : }
        2213                 :            :
        2214                 :            :
        2215                 :            : /*[clinic input]
        2216                 :            : _asyncio.Task.cancel
        2217                 :            :
        2218                 :            :     msg: object = None
        2219                 :            :
        2220                 :            : Request that this task cancel itself.
        2221                 :            :
        2222                 :            : This arranges for a CancelledError to be thrown into the
        2223                 :            : wrapped coroutine on the next cycle through the event loop.
        2224                 :            : The coroutine then has a chance to clean up or even deny
        2225                 :            : the request using try/except/finally.
        2226                 :            :
        2227                 :            : Unlike Future.cancel, this does not guarantee that the
        2228                 :            : task will be cancelled: the exception might be caught and
        2229                 :            : acted upon, delaying cancellation of the task or preventing
        2230                 :            : cancellation completely.  The task may also return a value or
        2231                 :            : raise a different exception.
        2232                 :            :
        2233                 :            : Immediately after this method is called, Task.cancelled() will
        2234                 :            : not return True (unless the task was already cancelled).  A
        2235                 :            : task will be marked as cancelled when the wrapped coroutine
        2236                 :            : terminates with a CancelledError exception (even if cancel()
        2237                 :            : was not called).
        2238                 :            :
        2239                 :            : This also increases the task's count of cancellation requests.
        2240                 :            : [clinic start generated code]*/
        2241                 :            :
        2242                 :            : static PyObject *
        2243                 :          0 : _asyncio_Task_cancel_impl(TaskObj *self, PyObject *msg)
        2244                 :            : /*[clinic end generated code: output=c66b60d41c74f9f1 input=7bb51bf25974c783]*/
        2245                 :            : {
        2246                 :          0 :     self->task_log_tb = 0;
        2247                 :            :
        2248         [ #  # ]:          0 :     if (self->task_state != STATE_PENDING) {
        2249                 :          0 :         Py_RETURN_FALSE;
        2250                 :            :     }
        2251                 :            :
        2252                 :          0 :     self->task_num_cancels_requested += 1;
        2253                 :            :
        2254                 :            :     // These three lines are controversial.  See discussion starting at
        2255                 :            :     // https://github.com/python/cpython/pull/31394#issuecomment-1053545331
        2256                 :            :     // and corresponding code in tasks.py.
        2257                 :            :     // if (self->task_num_cancels_requested > 1) {
        2258                 :            :     //     Py_RETURN_FALSE;
        2259                 :            :     // }
        2260                 :            :
        2261         [ #  # ]:          0 :     if (self->task_fut_waiter) {
        2262                 :            :         PyObject *res;
        2263                 :            :         int is_true;
        2264                 :            :
        2265                 :          0 :         res = PyObject_CallMethodOneArg(self->task_fut_waiter,
        2266                 :            :                                            &_Py_ID(cancel), msg);
        2267         [ #  # ]:          0 :         if (res == NULL) {
        2268                 :          0 :             return NULL;
        2269                 :            :         }
        2270                 :            :
        2271                 :          0 :         is_true = PyObject_IsTrue(res);
        2272                 :          0 :         Py_DECREF(res);
        2273         [ #  # ]:          0 :         if (is_true < 0) {
        2274                 :          0 :             return NULL;
        2275                 :            :         }
        2276                 :            :
        2277         [ #  # ]:          0 :         if (is_true) {
        2278                 :          0 :             Py_RETURN_TRUE;
        2279                 :            :         }
        2280                 :            :     }
        2281                 :            :
        2282                 :          0 :     self->task_must_cancel = 1;
        2283                 :          0 :     Py_XINCREF(msg);
        2284                 :          0 :     Py_XSETREF(self->task_cancel_msg, msg);
        2285                 :          0 :     Py_RETURN_TRUE;
        2286                 :            : }
        2287                 :            :
        2288                 :            : /*[clinic input]
        2289                 :            : _asyncio.Task.cancelling
        2290                 :            :
        2291                 :            : Return the count of the task's cancellation requests.
        2292                 :            :
        2293                 :            : This count is incremented when .cancel() is called
        2294                 :            : and may be decremented using .uncancel().
        2295                 :            : [clinic start generated code]*/
        2296                 :            :
        2297                 :            : static PyObject *
        2298                 :          0 : _asyncio_Task_cancelling_impl(TaskObj *self)
        2299                 :            : /*[clinic end generated code: output=803b3af96f917d7e input=b625224d310cbb17]*/
        2300                 :            : /*[clinic end generated code]*/
        2301                 :            : {
        2302                 :          0 :     return PyLong_FromLong(self->task_num_cancels_requested);
        2303                 :            : }
        2304                 :            :
        2305                 :            : /*[clinic input]
        2306                 :            : _asyncio.Task.uncancel
        2307                 :            :
        2308                 :            : Decrement the task's count of cancellation requests.
        2309                 :            :
        2310                 :            : This should be used by tasks that catch CancelledError
        2311                 :            : and wish to continue indefinitely until they are cancelled again.
        2312                 :            :
        2313                 :            : Returns the remaining number of cancellation requests.
        2314                 :            : [clinic start generated code]*/
        2315                 :            :
        2316                 :            : static PyObject *
        2317                 :          0 : _asyncio_Task_uncancel_impl(TaskObj *self)
        2318                 :            : /*[clinic end generated code: output=58184d236a817d3c input=68f81a4b90b46be2]*/
        2319                 :            : /*[clinic end generated code]*/
        2320                 :            : {
        2321         [ #  # ]:          0 :     if (self->task_num_cancels_requested > 0) {
        2322                 :          0 :         self->task_num_cancels_requested -= 1;
        2323                 :            :     }
        2324                 :          0 :     return PyLong_FromLong(self->task_num_cancels_requested);
        2325                 :            : }
        2326                 :            :
        2327                 :            : /*[clinic input]
        2328                 :            : _asyncio.Task.get_stack
        2329                 :            :
        2330                 :            :     cls: defining_class
        2331                 :            :     /
        2332                 :            :     *
        2333                 :            :     limit: object = None
        2334                 :            :
        2335                 :            : Return the list of stack frames for this task's coroutine.
        2336                 :            :
        2337                 :            : If the coroutine is not done, this returns the stack where it is
        2338                 :            : suspended.  If the coroutine has completed successfully or was
        2339                 :            : cancelled, this returns an empty list.  If the coroutine was
        2340                 :            : terminated by an exception, this returns the list of traceback
        2341                 :            : frames.
        2342                 :            :
        2343                 :            : The frames are always ordered from oldest to newest.
        2344                 :            :
        2345                 :            : The optional limit gives the maximum number of frames to
        2346                 :            : return; by default all available frames are returned.  Its
        2347                 :            : meaning differs depending on whether a stack or a traceback is
        2348                 :            : returned: the newest frames of a stack are returned, but the
        2349                 :            : oldest frames of a traceback are returned.  (This matches the
        2350                 :            : behavior of the traceback module.)
        2351                 :            :
        2352                 :            : For reasons beyond our control, only one stack frame is
        2353                 :            : returned for a suspended coroutine.
        2354                 :            : [clinic start generated code]*/
        2355                 :            :
        2356                 :            : static PyObject *
        2357                 :          0 : _asyncio_Task_get_stack_impl(TaskObj *self, PyTypeObject *cls,
        2358                 :            :                              PyObject *limit)
        2359                 :            : /*[clinic end generated code: output=6774dfc10d3857fa input=8e01c9b2618ae953]*/
        2360                 :            : {
        2361                 :          0 :     asyncio_state *state = get_asyncio_state_by_cls(cls);
        2362                 :          0 :     return PyObject_CallFunctionObjArgs(
        2363                 :            :         state->asyncio_task_get_stack_func, self, limit, NULL);
        2364                 :            : }
        2365                 :            :
        2366                 :            : /*[clinic input]
        2367                 :            : _asyncio.Task.print_stack
        2368                 :            :
        2369                 :            :     cls: defining_class
        2370                 :            :     /
        2371                 :            :     *
        2372                 :            :     limit: object = None
        2373                 :            :     file: object = None
        2374                 :            :
        2375                 :            : Print the stack or traceback for this task's coroutine.
        2376                 :            :
        2377                 :            : This produces output similar to that of the traceback module,
        2378                 :            : for the frames retrieved by get_stack().  The limit argument
        2379                 :            : is passed to get_stack().  The file argument is an I/O stream
        2380                 :            : to which the output is written; by default output is written
        2381                 :            : to sys.stderr.
        2382                 :            : [clinic start generated code]*/
        2383                 :            :
        2384                 :            : static PyObject *
        2385                 :          0 : _asyncio_Task_print_stack_impl(TaskObj *self, PyTypeObject *cls,
        2386                 :            :                                PyObject *limit, PyObject *file)
        2387                 :            : /*[clinic end generated code: output=b38affe9289ec826 input=150b35ba2d3a7dee]*/
        2388                 :            : {
        2389                 :          0 :     asyncio_state *state = get_asyncio_state_by_cls(cls);
        2390                 :          0 :     return PyObject_CallFunctionObjArgs(
        2391                 :            :         state->asyncio_task_print_stack_func, self, limit, file, NULL);
        2392                 :            : }
        2393                 :            :
        2394                 :            : /*[clinic input]
        2395                 :            : _asyncio.Task.set_result
        2396                 :            :
        2397                 :            :     result: object
        2398                 :            :     /
        2399                 :            : [clinic start generated code]*/
        2400                 :            :
        2401                 :            : static PyObject *
        2402                 :          0 : _asyncio_Task_set_result(TaskObj *self, PyObject *result)
        2403                 :            : /*[clinic end generated code: output=1dcae308bfcba318 input=9d1a00c07be41bab]*/
        2404                 :            : {
        2405                 :          0 :     PyErr_SetString(PyExc_RuntimeError,
        2406                 :            :                     "Task does not support set_result operation");
        2407                 :          0 :     return NULL;
        2408                 :            : }
        2409                 :            :
        2410                 :            : /*[clinic input]
        2411                 :            : _asyncio.Task.set_exception
        2412                 :            :
        2413                 :            :     exception: object
        2414                 :            :     /
        2415                 :            : [clinic start generated code]*/
        2416                 :            :
        2417                 :            : static PyObject *
        2418                 :          0 : _asyncio_Task_set_exception(TaskObj *self, PyObject *exception)
        2419                 :            : /*[clinic end generated code: output=bc377fc28067303d input=9a8f65c83dcf893a]*/
        2420                 :            : {
        2421                 :          0 :     PyErr_SetString(PyExc_RuntimeError,
        2422                 :            :                     "Task does not support set_exception operation");
        2423                 :          0 :     return NULL;
        2424                 :            : }
        2425                 :            :
        2426                 :            : /*[clinic input]
        2427                 :            : _asyncio.Task.get_coro
        2428                 :            : [clinic start generated code]*/
        2429                 :            :
        2430                 :            : static PyObject *
        2431                 :          0 : _asyncio_Task_get_coro_impl(TaskObj *self)
        2432                 :            : /*[clinic end generated code: output=bcac27c8cc6c8073 input=d2e8606c42a7b403]*/
        2433                 :            : {
        2434                 :          0 :     return Py_NewRef(self->task_coro);
        2435                 :            : }
        2436                 :            :
        2437                 :            : /*[clinic input]
        2438                 :            : _asyncio.Task.get_context
        2439                 :            : [clinic start generated code]*/
        2440                 :            :
        2441                 :            : static PyObject *
        2442                 :          0 : _asyncio_Task_get_context_impl(TaskObj *self)
        2443                 :            : /*[clinic end generated code: output=6996f53d3dc01aef input=87c0b209b8fceeeb]*/
        2444                 :            : {
        2445                 :          0 :     return Py_NewRef(self->task_context);
        2446                 :            : }
        2447                 :            :
        2448                 :            : /*[clinic input]
        2449                 :            : _asyncio.Task.get_name
        2450                 :            : [clinic start generated code]*/
        2451                 :            :
        2452                 :            : static PyObject *
        2453                 :          0 : _asyncio_Task_get_name_impl(TaskObj *self)
        2454                 :            : /*[clinic end generated code: output=0ecf1570c3b37a8f input=a4a6595d12f4f0f8]*/
        2455                 :            : {
        2456         [ #  # ]:          0 :     if (self->task_name) {
        2457                 :          0 :         return Py_NewRef(self->task_name);
        2458                 :            :     }
        2459                 :            :
        2460                 :          0 :     Py_RETURN_NONE;
        2461                 :            : }
        2462                 :            :
        2463                 :            : /*[clinic input]
        2464                 :            : _asyncio.Task.set_name
        2465                 :            :
        2466                 :            :     value: object
        2467                 :            :     /
        2468                 :            : [clinic start generated code]*/
        2469                 :            :
        2470                 :            : static PyObject *
        2471                 :          0 : _asyncio_Task_set_name(TaskObj *self, PyObject *value)
        2472                 :            : /*[clinic end generated code: output=138a8d51e32057d6 input=a8359b6e65f8fd31]*/
        2473                 :            : {
        2474         [ #  # ]:          0 :     if (!PyUnicode_CheckExact(value)) {
        2475                 :          0 :         value = PyObject_Str(value);
        2476         [ #  # ]:          0 :         if (value == NULL) {
        2477                 :          0 :             return NULL;
        2478                 :            :         }
        2479                 :            :     } else {
        2480                 :          0 :         Py_INCREF(value);
        2481                 :            :     }
        2482                 :            :
        2483                 :          0 :     Py_XSETREF(self->task_name, value);
        2484                 :          0 :     Py_RETURN_NONE;
        2485                 :            : }
        2486                 :            :
        2487                 :            : static void
        2488                 :          0 : TaskObj_finalize(TaskObj *task)
        2489                 :            : {
        2490                 :            :     PyObject *context;
        2491                 :          0 :     PyObject *message = NULL;
        2492                 :            :     PyObject *func;
        2493                 :            :
        2494   [ #  #  #  # ]:          0 :     if (task->task_state != STATE_PENDING || !task->task_log_destroy_pending) {
        2495                 :          0 :         goto done;
        2496                 :            :     }
        2497                 :            :
        2498                 :            :     /* Save the current exception, if any. */
        2499                 :          0 :     PyObject *exc = PyErr_GetRaisedException();
        2500                 :            :
        2501                 :          0 :     context = PyDict_New();
        2502         [ #  # ]:          0 :     if (context == NULL) {
        2503                 :          0 :         goto finally;
        2504                 :            :     }
        2505                 :            :
        2506                 :          0 :     message = PyUnicode_FromString("Task was destroyed but it is pending!");
        2507         [ #  # ]:          0 :     if (message == NULL) {
        2508                 :          0 :         goto finally;
        2509                 :            :     }
        2510                 :            :
        2511   [ #  #  #  # ]:          0 :     if (PyDict_SetItem(context, &_Py_ID(message), message) < 0 ||
        2512                 :          0 :         PyDict_SetItem(context, &_Py_ID(task), (PyObject*)task) < 0)
        2513                 :            :     {
        2514                 :          0 :         goto finally;
        2515                 :            :     }
        2516                 :            :
        2517         [ #  # ]:          0 :     if (task->task_source_tb != NULL) {
        2518         [ #  # ]:          0 :         if (PyDict_SetItem(context, &_Py_ID(source_traceback),
        2519                 :            :                               task->task_source_tb) < 0)
        2520                 :            :         {
        2521                 :          0 :             goto finally;
        2522                 :            :         }
        2523                 :            :     }
        2524                 :            :
        2525                 :          0 :     func = PyObject_GetAttr(task->task_loop, &_Py_ID(call_exception_handler));
        2526         [ #  # ]:          0 :     if (func != NULL) {
        2527                 :          0 :         PyObject *res = PyObject_CallOneArg(func, context);
        2528         [ #  # ]:          0 :         if (res == NULL) {
        2529                 :          0 :             PyErr_WriteUnraisable(func);
        2530                 :            :         }
        2531                 :            :         else {
        2532                 :          0 :             Py_DECREF(res);
        2533                 :            :         }
        2534                 :          0 :         Py_DECREF(func);
        2535                 :            :     }
        2536                 :            :
        2537                 :          0 : finally:
        2538                 :          0 :     Py_XDECREF(context);
        2539                 :          0 :     Py_XDECREF(message);
        2540                 :            :
        2541                 :            :     /* Restore the saved exception. */
        2542                 :          0 :     PyErr_SetRaisedException(exc);
        2543                 :            :
        2544                 :          0 : done:
        2545                 :          0 :     FutureObj_finalize((FutureObj*)task);
        2546                 :          0 : }
        2547                 :            :
        2548                 :            : static void TaskObj_dealloc(PyObject *);  /* Needs Task_CheckExact */
        2549                 :            :
        2550                 :            : static PyMethodDef TaskType_methods[] = {
        2551                 :            :     _ASYNCIO_FUTURE_RESULT_METHODDEF
        2552                 :            :     _ASYNCIO_FUTURE_EXCEPTION_METHODDEF
        2553                 :            :     _ASYNCIO_FUTURE_ADD_DONE_CALLBACK_METHODDEF
        2554                 :            :     _ASYNCIO_FUTURE_REMOVE_DONE_CALLBACK_METHODDEF
        2555                 :            :     _ASYNCIO_FUTURE_CANCELLED_METHODDEF
        2556                 :            :     _ASYNCIO_FUTURE_DONE_METHODDEF
        2557                 :            :     _ASYNCIO_TASK_SET_RESULT_METHODDEF
        2558                 :            :     _ASYNCIO_TASK_SET_EXCEPTION_METHODDEF
        2559                 :            :     _ASYNCIO_TASK_CANCEL_METHODDEF
        2560                 :            :     _ASYNCIO_TASK_CANCELLING_METHODDEF
        2561                 :            :     _ASYNCIO_TASK_UNCANCEL_METHODDEF
        2562                 :            :     _ASYNCIO_TASK_GET_STACK_METHODDEF
        2563                 :            :     _ASYNCIO_TASK_PRINT_STACK_METHODDEF
        2564                 :            :     _ASYNCIO_TASK__MAKE_CANCELLED_ERROR_METHODDEF
        2565                 :            :     _ASYNCIO_TASK_GET_NAME_METHODDEF
        2566                 :            :     _ASYNCIO_TASK_SET_NAME_METHODDEF
        2567                 :            :     _ASYNCIO_TASK_GET_CORO_METHODDEF
        2568                 :            :     _ASYNCIO_TASK_GET_CONTEXT_METHODDEF
        2569                 :            :     {"__class_getitem__", Py_GenericAlias, METH_O|METH_CLASS, PyDoc_STR("See PEP 585")},
        2570                 :            :     {NULL, NULL}        /* Sentinel */
        2571                 :            : };
        2572                 :            :
        2573                 :            : static PyMemberDef TaskType_members[] = {
        2574                 :            :     {"__weaklistoffset__", T_PYSSIZET, offsetof(TaskObj, task_weakreflist), READONLY},
        2575                 :            :     {"__dictoffset__", T_PYSSIZET, offsetof(TaskObj, dict), READONLY},
        2576                 :            :     {NULL},
        2577                 :            : };
        2578                 :            :
        2579                 :            : static PyGetSetDef TaskType_getsetlist[] = {
        2580                 :            :     FUTURE_COMMON_GETSETLIST
        2581                 :            :     {"_log_destroy_pending", (getter)TaskObj_get_log_destroy_pending,
        2582                 :            :                              (setter)TaskObj_set_log_destroy_pending, NULL},
        2583                 :            :     {"_must_cancel", (getter)TaskObj_get_must_cancel, NULL, NULL},
        2584                 :            :     {"_coro", (getter)TaskObj_get_coro, NULL, NULL},
        2585                 :            :     {"_fut_waiter", (getter)TaskObj_get_fut_waiter, NULL, NULL},
        2586                 :            :     {NULL} /* Sentinel */
        2587                 :            : };
        2588                 :            :
        2589                 :            : static PyType_Slot Task_slots[] = {
        2590                 :            :     {Py_tp_dealloc, TaskObj_dealloc},
        2591                 :            :     {Py_tp_repr, (reprfunc)TaskObj_repr},
        2592                 :            :     {Py_tp_doc, (void *)_asyncio_Task___init____doc__},
        2593                 :            :     {Py_tp_traverse, (traverseproc)TaskObj_traverse},
        2594                 :            :     {Py_tp_clear, (inquiry)TaskObj_clear},
        2595                 :            :     {Py_tp_iter, (getiterfunc)future_new_iter},
        2596                 :            :     {Py_tp_methods, TaskType_methods},
        2597                 :            :     {Py_tp_members, TaskType_members},
        2598                 :            :     {Py_tp_getset, TaskType_getsetlist},
        2599                 :            :     {Py_tp_init, (initproc)_asyncio_Task___init__},
        2600                 :            :     {Py_tp_new, PyType_GenericNew},
        2601                 :            :     {Py_tp_finalize, (destructor)TaskObj_finalize},
        2602                 :            :
        2603                 :            :     // async slots
        2604                 :            :     {Py_am_await, (unaryfunc)future_new_iter},
        2605                 :            :     {0, NULL},
        2606                 :            : };
        2607                 :            :
        2608                 :            : static PyType_Spec Task_spec = {
        2609                 :            :     .name = "_asyncio.Task",
        2610                 :            :     .basicsize = sizeof(TaskObj),
        2611                 :            :     .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE |
        2612                 :            :               Py_TPFLAGS_IMMUTABLETYPE),
        2613                 :            :     .slots = Task_slots,
        2614                 :            : };
        2615                 :            :
        2616                 :            : static void
        2617                 :          0 : TaskObj_dealloc(PyObject *self)
        2618                 :            : {
        2619                 :          0 :     TaskObj *task = (TaskObj *)self;
        2620                 :            :
        2621         [ #  # ]:          0 :     if (PyObject_CallFinalizerFromDealloc(self) < 0) {
        2622                 :            :         // resurrected.
        2623                 :          0 :         return;
        2624                 :            :     }
        2625                 :            :
        2626                 :          0 :     PyTypeObject *tp = Py_TYPE(task);
        2627                 :          0 :     PyObject_GC_UnTrack(self);
        2628                 :            :
        2629         [ #  # ]:          0 :     if (task->task_weakreflist != NULL) {
        2630                 :          0 :         PyObject_ClearWeakRefs(self);
        2631                 :            :     }
        2632                 :            :
        2633                 :          0 :     (void)TaskObj_clear(task);
        2634                 :          0 :     tp->tp_free(task);
        2635                 :          0 :     Py_DECREF(tp);
        2636                 :            : }
        2637                 :            :
        2638                 :            : static int
        2639                 :          0 : task_call_step_soon(asyncio_state *state, TaskObj *task, PyObject *arg)
        2640                 :            : {
        2641                 :          0 :     PyObject *cb = TaskStepMethWrapper_new(task, arg);
        2642         [ #  # ]:          0 :     if (cb == NULL) {
        2643                 :          0 :         return -1;
        2644                 :            :     }
        2645                 :            :
        2646                 :          0 :     int ret = call_soon(state, task->task_loop, cb, NULL, task->task_context);
        2647                 :          0 :     Py_DECREF(cb);
        2648                 :          0 :     return ret;
        2649                 :            : }
        2650                 :            :
        2651                 :            : static PyObject *
        2652                 :          0 : task_set_error_soon(asyncio_state *state, TaskObj *task, PyObject *et,
        2653                 :            :                     const char *format, ...)
        2654                 :            : {
        2655                 :            :     PyObject* msg;
        2656                 :            :
        2657                 :            :     va_list vargs;
        2658                 :          0 :     va_start(vargs, format);
        2659                 :          0 :     msg = PyUnicode_FromFormatV(format, vargs);
        2660                 :          0 :     va_end(vargs);
        2661                 :            :
        2662         [ #  # ]:          0 :     if (msg == NULL) {
        2663                 :          0 :         return NULL;
        2664                 :            :     }
        2665                 :            :
        2666                 :          0 :     PyObject *e = PyObject_CallOneArg(et, msg);
        2667                 :          0 :     Py_DECREF(msg);
        2668         [ #  # ]:          0 :     if (e == NULL) {
        2669                 :          0 :         return NULL;
        2670                 :            :     }
        2671                 :            :
        2672         [ #  # ]:          0 :     if (task_call_step_soon(state, task, e) == -1) {
        2673                 :          0 :         Py_DECREF(e);
        2674                 :          0 :         return NULL;
        2675                 :            :     }
        2676                 :            :
        2677                 :          0 :     Py_DECREF(e);
        2678                 :          0 :     Py_RETURN_NONE;
        2679                 :            : }
        2680                 :            :
        2681                 :            : static inline int
        2682                 :          0 : gen_status_from_result(PyObject **result)
        2683                 :            : {
        2684         [ #  # ]:          0 :     if (*result != NULL) {
        2685                 :          0 :         return PYGEN_NEXT;
        2686                 :            :     }
        2687         [ #  # ]:          0 :     if (_PyGen_FetchStopIterationValue(result) == 0) {
        2688                 :          0 :         return PYGEN_RETURN;
        2689                 :            :     }
        2690                 :            :
        2691                 :            :     assert(PyErr_Occurred());
        2692                 :          0 :     return PYGEN_ERROR;
        2693                 :            : }
        2694                 :            :
        2695                 :            : static PyObject *
        2696                 :          0 : task_step_impl(asyncio_state *state, TaskObj *task, PyObject *exc)
        2697                 :            : {
        2698                 :            :     int res;
        2699                 :          0 :     int clear_exc = 0;
        2700                 :          0 :     PyObject *result = NULL;
        2701                 :            :     PyObject *coro;
        2702                 :            :     PyObject *o;
        2703                 :            :
        2704         [ #  # ]:          0 :     if (task->task_state != STATE_PENDING) {
        2705         [ #  # ]:          0 :         PyErr_Format(state->asyncio_InvalidStateError,
        2706                 :            :                      "_step(): already done: %R %R",
        2707                 :            :                      task,
        2708                 :            :                      exc ? exc : Py_None);
        2709                 :          0 :         goto fail;
        2710                 :            :     }
        2711                 :            :
        2712         [ #  # ]:          0 :     if (task->task_must_cancel) {
        2713                 :            :         assert(exc != Py_None);
        2714                 :            :
        2715         [ #  # ]:          0 :         if (exc) {
        2716                 :            :             /* Check if exc is a CancelledError */
        2717                 :          0 :             res = PyObject_IsInstance(exc, state->asyncio_CancelledError);
        2718         [ #  # ]:          0 :             if (res == -1) {
        2719                 :            :                 /* An error occurred, abort */
        2720                 :          0 :                 goto fail;
        2721                 :            :             }
        2722         [ #  # ]:          0 :             if (res == 0) {
        2723                 :            :                 /* exc is not CancelledError; reset it to NULL */
        2724                 :          0 :                 exc = NULL;
        2725                 :            :             }
        2726                 :            :         }
        2727                 :            :
        2728         [ #  # ]:          0 :         if (!exc) {
        2729                 :            :             /* exc was not a CancelledError */
        2730                 :          0 :             exc = create_cancelled_error(state, (FutureObj*)task);
        2731                 :            :
        2732         [ #  # ]:          0 :             if (!exc) {
        2733                 :          0 :                 goto fail;
        2734                 :            :             }
        2735                 :          0 :             clear_exc = 1;
        2736                 :            :         }
        2737                 :            :
        2738                 :          0 :         task->task_must_cancel = 0;
        2739                 :            :     }
        2740                 :            :
        2741         [ #  # ]:          0 :     Py_CLEAR(task->task_fut_waiter);
        2742                 :            :
        2743                 :          0 :     coro = task->task_coro;
        2744         [ #  # ]:          0 :     if (coro == NULL) {
        2745                 :          0 :         PyErr_SetString(PyExc_RuntimeError, "uninitialized Task object");
        2746         [ #  # ]:          0 :         if (clear_exc) {
        2747                 :            :             /* We created 'exc' during this call */
        2748                 :          0 :             Py_DECREF(exc);
        2749                 :            :         }
        2750                 :          0 :         return NULL;
        2751                 :            :     }
        2752                 :            :
        2753                 :          0 :     int gen_status = PYGEN_ERROR;
        2754         [ #  # ]:          0 :     if (exc == NULL) {
        2755                 :          0 :         gen_status = PyIter_Send(coro, Py_None, &result);
        2756                 :            :     }
        2757                 :            :     else {
        2758                 :          0 :         result = PyObject_CallMethodOneArg(coro, &_Py_ID(throw), exc);
        2759                 :          0 :         gen_status = gen_status_from_result(&result);
        2760         [ #  # ]:          0 :         if (clear_exc) {
        2761                 :            :             /* We created 'exc' during this call */
        2762                 :          0 :             Py_DECREF(exc);
        2763                 :            :         }
        2764                 :            :     }
        2765                 :            :
        2766   [ #  #  #  # ]:          0 :     if (gen_status == PYGEN_RETURN || gen_status == PYGEN_ERROR) {
        2767         [ #  # ]:          0 :         if (result != NULL) {
        2768                 :            :             /* The error is StopIteration and that means that
        2769                 :            :                the underlying coroutine has resolved */
        2770                 :            :
        2771                 :            :             PyObject *tmp;
        2772         [ #  # ]:          0 :             if (task->task_must_cancel) {
        2773                 :            :                 // Task is cancelled right before coro stops.
        2774                 :          0 :                 task->task_must_cancel = 0;
        2775                 :          0 :                 tmp = future_cancel(state, (FutureObj*)task,
        2776                 :            :                                     task->task_cancel_msg);
        2777                 :            :             }
        2778                 :            :             else {
        2779                 :          0 :                 tmp = future_set_result(state, (FutureObj*)task, result);
        2780                 :            :             }
        2781                 :            :
        2782                 :          0 :             Py_DECREF(result);
        2783                 :            :
        2784         [ #  # ]:          0 :             if (tmp == NULL) {
        2785                 :          0 :                 return NULL;
        2786                 :            :             }
        2787                 :          0 :             Py_DECREF(tmp);
        2788                 :          0 :             Py_RETURN_NONE;
        2789                 :            :         }
        2790                 :            :
        2791         [ #  # ]:          0 :         if (PyErr_ExceptionMatches(state->asyncio_CancelledError)) {
        2792                 :            :             /* CancelledError */
        2793                 :            :
        2794                 :          0 :             PyObject *exc = PyErr_GetRaisedException();
        2795                 :            :             assert(exc);
        2796                 :            :
        2797                 :          0 :             FutureObj *fut = (FutureObj*)task;
        2798                 :            :             /* transfer ownership */
        2799                 :          0 :             fut->fut_cancelled_exc = exc;
        2800                 :            :
        2801                 :          0 :             return future_cancel(state, fut, NULL);
        2802                 :            :         }
        2803                 :            :
        2804                 :            :         /* Some other exception; pop it and call Task.set_exception() */
        2805                 :          0 :         PyObject *exc = PyErr_GetRaisedException();
        2806                 :            :         assert(exc);
        2807                 :            :
        2808                 :          0 :         o = future_set_exception(state, (FutureObj*)task, exc);
        2809         [ #  # ]:          0 :         if (!o) {
        2810                 :            :             /* An exception in Task.set_exception() */
        2811                 :          0 :             Py_DECREF(exc);
        2812                 :          0 :             goto fail;
        2813                 :            :         }
        2814                 :            :         assert(o == Py_None);
        2815                 :          0 :         Py_DECREF(o);
        2816                 :            :
        2817   [ #  #  #  # ]:          0 :         if (PyErr_GivenExceptionMatches(exc, PyExc_KeyboardInterrupt) ||
        2818                 :          0 :             PyErr_GivenExceptionMatches(exc, PyExc_SystemExit))
        2819                 :            :         {
        2820                 :            :             /* We've got a KeyboardInterrupt or a SystemError; re-raise it */
        2821                 :          0 :             PyErr_SetRaisedException(exc);
        2822                 :          0 :             goto fail;
        2823                 :            :         }
        2824                 :            :
        2825                 :          0 :         Py_DECREF(exc);
        2826                 :            :
        2827                 :          0 :         Py_RETURN_NONE;
        2828                 :            :     }
        2829                 :            :
        2830         [ #  # ]:          0 :     if (result == (PyObject*)task) {
        2831                 :            :         /* We have a task that wants to await on itself */
        2832                 :          0 :         goto self_await;
        2833                 :            :     }
        2834                 :            :
        2835                 :            :     /* Check if `result` is FutureObj or TaskObj (and not a subclass) */
        2836   [ #  #  #  # ]:          0 :     if (Future_CheckExact(state, result) || Task_CheckExact(state, result)) {
        2837                 :            :         PyObject *wrapper;
        2838                 :            :         PyObject *tmp;
        2839                 :          0 :         FutureObj *fut = (FutureObj*)result;
        2840                 :            :
        2841                 :            :         /* Check if `result` future is attached to a different loop */
        2842         [ #  # ]:          0 :         if (fut->fut_loop != task->task_loop) {
        2843                 :          0 :             goto different_loop;
        2844                 :            :         }
        2845                 :            :
        2846         [ #  # ]:          0 :         if (!fut->fut_blocking) {
        2847                 :          0 :             goto yield_insteadof_yf;
        2848                 :            :         }
        2849                 :            :
        2850                 :          0 :         fut->fut_blocking = 0;
        2851                 :            :
        2852                 :            :         /* result.add_done_callback(task._wakeup) */
        2853                 :          0 :         wrapper = PyCFunction_New(&TaskWakeupDef, (PyObject *)task);
        2854         [ #  # ]:          0 :         if (wrapper == NULL) {
        2855                 :          0 :             goto fail;
        2856                 :            :         }
        2857                 :          0 :         tmp = future_add_done_callback(state,
        2858                 :            :             (FutureObj*)result, wrapper, task->task_context);
        2859                 :          0 :         Py_DECREF(wrapper);
        2860         [ #  # ]:          0 :         if (tmp == NULL) {
        2861                 :          0 :             goto fail;
        2862                 :            :         }
        2863                 :          0 :         Py_DECREF(tmp);
        2864                 :            :
        2865                 :            :         /* task._fut_waiter = result */
        2866                 :          0 :         task->task_fut_waiter = result;  /* no incref is necessary */
        2867                 :            :
        2868         [ #  # ]:          0 :         if (task->task_must_cancel) {
        2869                 :            :             PyObject *r;
        2870                 :            :             int is_true;
        2871                 :          0 :             r = PyObject_CallMethodOneArg(result, &_Py_ID(cancel),
        2872                 :            :                                              task->task_cancel_msg);
        2873         [ #  # ]:          0 :             if (r == NULL) {
        2874                 :          0 :                 return NULL;
        2875                 :            :             }
        2876                 :          0 :             is_true = PyObject_IsTrue(r);
        2877                 :          0 :             Py_DECREF(r);
        2878         [ #  # ]:          0 :             if (is_true < 0) {
        2879                 :          0 :                 return NULL;
        2880                 :            :             }
        2881         [ #  # ]:          0 :             else if (is_true) {
        2882                 :          0 :                 task->task_must_cancel = 0;
        2883                 :            :             }
        2884                 :            :         }
        2885                 :            :
        2886                 :          0 :         Py_RETURN_NONE;
        2887                 :            :     }
        2888                 :            :
        2889                 :            :     /* Check if `result` is None */
        2890         [ #  # ]:          0 :     if (result == Py_None) {
        2891                 :            :         /* Bare yield relinquishes control for one event loop iteration. */
        2892         [ #  # ]:          0 :         if (task_call_step_soon(state, task, NULL)) {
        2893                 :          0 :             goto fail;
        2894                 :            :         }
        2895                 :          0 :         return result;
        2896                 :            :     }
        2897                 :            :
        2898                 :            :     /* Check if `result` is a Future-compatible object */
        2899         [ #  # ]:          0 :     if (_PyObject_LookupAttr(result, &_Py_ID(_asyncio_future_blocking), &o) < 0) {
        2900                 :          0 :         goto fail;
        2901                 :            :     }
        2902   [ #  #  #  # ]:          0 :     if (o != NULL && o != Py_None) {
        2903                 :            :         /* `result` is a Future-compatible object */
        2904                 :            :         PyObject *wrapper;
        2905                 :            :         PyObject *tmp;
        2906                 :            :
        2907                 :          0 :         int blocking = PyObject_IsTrue(o);
        2908                 :          0 :         Py_DECREF(o);
        2909         [ #  # ]:          0 :         if (blocking < 0) {
        2910                 :          0 :             goto fail;
        2911                 :            :         }
        2912                 :            :
        2913                 :            :         /* Check if `result` future is attached to a different loop */
        2914                 :          0 :         PyObject *oloop = get_future_loop(state, result);
        2915         [ #  # ]:          0 :         if (oloop == NULL) {
        2916                 :          0 :             goto fail;
        2917                 :            :         }
        2918         [ #  # ]:          0 :         if (oloop != task->task_loop) {
        2919                 :          0 :             Py_DECREF(oloop);
        2920                 :          0 :             goto different_loop;
        2921                 :            :         }
        2922                 :          0 :         Py_DECREF(oloop);
        2923                 :            :
        2924         [ #  # ]:          0 :         if (!blocking) {
        2925                 :          0 :             goto yield_insteadof_yf;
        2926                 :            :         }
        2927                 :            :
        2928                 :            :         /* result._asyncio_future_blocking = False */
        2929         [ #  # ]:          0 :         if (PyObject_SetAttr(
        2930                 :            :                 result, &_Py_ID(_asyncio_future_blocking), Py_False) == -1) {
        2931                 :          0 :             goto fail;
        2932                 :            :         }
        2933                 :            :
        2934                 :          0 :         wrapper = PyCFunction_New(&TaskWakeupDef, (PyObject *)task);
        2935         [ #  # ]:          0 :         if (wrapper == NULL) {
        2936                 :          0 :             goto fail;
        2937                 :            :         }
        2938                 :            :
        2939                 :            :         /* result.add_done_callback(task._wakeup) */
        2940                 :          0 :         PyObject *add_cb = PyObject_GetAttr(
        2941                 :            :             result, &_Py_ID(add_done_callback));
        2942         [ #  # ]:          0 :         if (add_cb == NULL) {
        2943                 :          0 :             Py_DECREF(wrapper);
        2944                 :          0 :             goto fail;
        2945                 :            :         }
        2946                 :            :         PyObject *stack[2];
        2947                 :          0 :         stack[0] = wrapper;
        2948                 :          0 :         stack[1] = (PyObject *)task->task_context;
        2949                 :            :         EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_API, add_cb);
        2950                 :          0 :         tmp = PyObject_Vectorcall(add_cb, stack, 1, state->context_kwname);
        2951                 :          0 :         Py_DECREF(add_cb);
        2952                 :          0 :         Py_DECREF(wrapper);
        2953         [ #  # ]:          0 :         if (tmp == NULL) {
        2954                 :          0 :             goto fail;
        2955                 :            :         }
        2956                 :          0 :         Py_DECREF(tmp);
        2957                 :            :
        2958                 :            :         /* task._fut_waiter = result */
        2959                 :          0 :         task->task_fut_waiter = result;  /* no incref is necessary */
        2960                 :            :
        2961         [ #  # ]:          0 :         if (task->task_must_cancel) {
        2962                 :            :             PyObject *r;
        2963                 :            :             int is_true;
        2964                 :          0 :             r = PyObject_CallMethodOneArg(result, &_Py_ID(cancel),
        2965                 :            :                                              task->task_cancel_msg);
        2966         [ #  # ]:          0 :             if (r == NULL) {
        2967                 :          0 :                 return NULL;
        2968                 :            :             }
        2969                 :          0 :             is_true = PyObject_IsTrue(r);
        2970                 :          0 :             Py_DECREF(r);
        2971         [ #  # ]:          0 :             if (is_true < 0) {
        2972                 :          0 :                 return NULL;
        2973                 :            :             }
        2974         [ #  # ]:          0 :             else if (is_true) {
        2975                 :          0 :                 task->task_must_cancel = 0;
        2976                 :            :             }
        2977                 :            :         }
        2978                 :            :
        2979                 :          0 :         Py_RETURN_NONE;
        2980                 :            :     }
        2981                 :            :
        2982                 :          0 :     Py_XDECREF(o);
        2983                 :            :     /* Check if `result` is a generator */
        2984                 :          0 :     res = PyObject_IsInstance(result, (PyObject*)&PyGen_Type);
        2985         [ #  # ]:          0 :     if (res < 0) {
        2986                 :          0 :         goto fail;
        2987                 :            :     }
        2988         [ #  # ]:          0 :     if (res) {
        2989                 :            :         /* `result` is a generator */
        2990                 :          0 :         o = task_set_error_soon(
        2991                 :            :             state, task, PyExc_RuntimeError,
        2992                 :            :             "yield was used instead of yield from for "
        2993                 :            :             "generator in task %R with %R", task, result);
        2994                 :          0 :         Py_DECREF(result);
        2995                 :          0 :         return o;
        2996                 :            :     }
        2997                 :            :
        2998                 :            :     /* The `result` is none of the above */
        2999                 :          0 :     o = task_set_error_soon(
        3000                 :            :         state, task, PyExc_RuntimeError, "Task got bad yield: %R", result);
        3001                 :          0 :     Py_DECREF(result);
        3002                 :          0 :     return o;
        3003                 :            :
        3004                 :          0 : self_await:
        3005                 :          0 :     o = task_set_error_soon(
        3006                 :            :         state, task, PyExc_RuntimeError,
        3007                 :            :         "Task cannot await on itself: %R", task);
        3008                 :          0 :     Py_DECREF(result);
        3009                 :          0 :     return o;
        3010                 :            :
        3011                 :          0 : yield_insteadof_yf:
        3012                 :          0 :     o = task_set_error_soon(
        3013                 :            :         state, task, PyExc_RuntimeError,
        3014                 :            :         "yield was used instead of yield from "
        3015                 :            :         "in task %R with %R",
        3016                 :            :         task, result);
        3017                 :          0 :     Py_DECREF(result);
        3018                 :          0 :     return o;
        3019                 :            :
        3020                 :          0 : different_loop:
        3021                 :          0 :     o = task_set_error_soon(
        3022                 :            :         state, task, PyExc_RuntimeError,
        3023                 :            :         "Task %R got Future %R attached to a different loop",
        3024                 :            :         task, result);
        3025                 :          0 :     Py_DECREF(result);
        3026                 :          0 :     return o;
        3027                 :            :
        3028                 :          0 : fail:
        3029                 :          0 :     Py_XDECREF(result);
        3030                 :          0 :     return NULL;
        3031                 :            : }
        3032                 :            :
        3033                 :            : static PyObject *
        3034                 :          0 : task_step(asyncio_state *state, TaskObj *task, PyObject *exc)
        3035                 :            : {
        3036                 :            :     PyObject *res;
        3037                 :            :
        3038         [ #  # ]:          0 :     if (enter_task(state, task->task_loop, (PyObject*)task) < 0) {
        3039                 :          0 :         return NULL;
        3040                 :            :     }
        3041                 :            :
        3042                 :          0 :     res = task_step_impl(state, task, exc);
        3043                 :            :
        3044         [ #  # ]:          0 :     if (res == NULL) {
        3045                 :          0 :         PyObject *exc = PyErr_GetRaisedException();
        3046                 :          0 :         leave_task(state, task->task_loop, (PyObject*)task);
        3047                 :          0 :         _PyErr_ChainExceptions1(exc);
        3048                 :          0 :         return NULL;
        3049                 :            :     }
        3050                 :            :     else {
        3051         [ #  # ]:          0 :         if (leave_task(state, task->task_loop, (PyObject*)task) < 0) {
        3052                 :          0 :             Py_DECREF(res);
        3053                 :          0 :             return NULL;
        3054                 :            :         }
        3055                 :            :         else {
        3056                 :          0 :             return res;
        3057                 :            :         }
        3058                 :            :     }
        3059                 :            : }
        3060                 :            :
        3061                 :            : static PyObject *
        3062                 :          0 : task_wakeup(TaskObj *task, PyObject *o)
        3063                 :            : {
        3064                 :            :     PyObject *result;
        3065                 :            :     assert(o);
        3066                 :            :
        3067                 :          0 :     asyncio_state *state = get_asyncio_state_by_def((PyObject *)task);
        3068   [ #  #  #  # ]:          0 :     if (Future_CheckExact(state, o) || Task_CheckExact(state, o)) {
        3069                 :          0 :         PyObject *fut_result = NULL;
        3070                 :          0 :         int res = future_get_result(state, (FutureObj*)o, &fut_result);
        3071                 :            :
        3072      [ #  #  # ]:          0 :         switch(res) {
        3073                 :          0 :         case -1:
        3074                 :            :             assert(fut_result == NULL);
        3075                 :          0 :             break; /* exception raised */
        3076                 :          0 :         case 0:
        3077                 :          0 :             Py_DECREF(fut_result);
        3078                 :          0 :             return task_step(state, task, NULL);
        3079                 :          0 :         default:
        3080                 :            :             assert(res == 1);
        3081                 :          0 :             result = task_step(state, task, fut_result);
        3082                 :          0 :             Py_DECREF(fut_result);
        3083                 :          0 :             return result;
        3084                 :            :         }
        3085                 :            :     }
        3086                 :            :     else {
        3087                 :          0 :         PyObject *fut_result = PyObject_CallMethod(o, "result", NULL);
        3088         [ #  # ]:          0 :         if (fut_result != NULL) {
        3089                 :          0 :             Py_DECREF(fut_result);
        3090                 :          0 :             return task_step(state, task, NULL);
        3091                 :            :         }
        3092                 :            :         /* exception raised */
        3093                 :            :     }
        3094                 :            :
        3095                 :          0 :     PyObject *exc = PyErr_GetRaisedException();
        3096                 :            :     assert(exc);
        3097                 :            :
        3098                 :          0 :     result = task_step(state, task, exc);
        3099                 :            :
        3100                 :          0 :     Py_DECREF(exc);
        3101                 :            :
        3102                 :          0 :     return result;
        3103                 :            : }
        3104                 :            :
        3105                 :            :
        3106                 :            : /*********************** Functions **************************/
        3107                 :            :
        3108                 :            :
        3109                 :            : /*[clinic input]
        3110                 :            : _asyncio._get_running_loop
        3111                 :            :
        3112                 :            : Return the running event loop or None.
        3113                 :            :
        3114                 :            : This is a low-level function intended to be used by event loops.
        3115                 :            : This function is thread-specific.
        3116                 :            :
        3117                 :            : [clinic start generated code]*/
        3118                 :            :
        3119                 :            : static PyObject *
        3120                 :          0 : _asyncio__get_running_loop_impl(PyObject *module)
        3121                 :            : /*[clinic end generated code: output=b4390af721411a0a input=0a21627e25a4bd43]*/
        3122                 :            : {
        3123                 :            :     PyObject *loop;
        3124                 :          0 :     asyncio_state *state = get_asyncio_state(module);
        3125         [ #  # ]:          0 :     if (get_running_loop(state, &loop)) {
        3126                 :          0 :         return NULL;
        3127                 :            :     }
        3128         [ #  # ]:          0 :     if (loop == NULL) {
        3129                 :            :         /* There's no currently running event loop */
        3130                 :          0 :         Py_RETURN_NONE;
        3131                 :            :     }
        3132                 :          0 :     return loop;
        3133                 :            : }
        3134                 :            :
        3135                 :            : /*[clinic input]
        3136                 :            : _asyncio._set_running_loop
        3137                 :            :     loop: 'O'
        3138                 :            :     /
        3139                 :            :
        3140                 :            : Set the running event loop.
        3141                 :            :
        3142                 :            : This is a low-level function intended to be used by event loops.
        3143                 :            : This function is thread-specific.
        3144                 :            : [clinic start generated code]*/
        3145                 :            :
        3146                 :            : static PyObject *
        3147                 :          0 : _asyncio__set_running_loop(PyObject *module, PyObject *loop)
        3148                 :            : /*[clinic end generated code: output=ae56bf7a28ca189a input=4c9720233d606604]*/
        3149                 :            : {
        3150                 :          0 :     asyncio_state *state = get_asyncio_state(module);
        3151         [ #  # ]:          0 :     if (set_running_loop(state, loop)) {
        3152                 :          0 :         return NULL;
        3153                 :            :     }
        3154                 :          0 :     Py_RETURN_NONE;
        3155                 :            : }
        3156                 :            :
        3157                 :            : /*[clinic input]
        3158                 :            : _asyncio.get_event_loop
        3159                 :            :
        3160                 :            : Return an asyncio event loop.
        3161                 :            :
        3162                 :            : When called from a coroutine or a callback (e.g. scheduled with
        3163                 :            : call_soon or similar API), this function will always return the
        3164                 :            : running event loop.
        3165                 :            :
        3166                 :            : If there is no running event loop set, the function will return
        3167                 :            : the result of `get_event_loop_policy().get_event_loop()` call.
        3168                 :            : [clinic start generated code]*/
        3169                 :            :
        3170                 :            : static PyObject *
        3171                 :          0 : _asyncio_get_event_loop_impl(PyObject *module)
        3172                 :            : /*[clinic end generated code: output=2a2d8b2f824c648b input=9364bf2916c8655d]*/
        3173                 :            : {
        3174                 :          0 :     asyncio_state *state = get_asyncio_state(module);
        3175                 :          0 :     return get_event_loop(state);
        3176                 :            : }
        3177                 :            :
        3178                 :            : /*[clinic input]
        3179                 :            : _asyncio.get_running_loop
        3180                 :            :
        3181                 :            : Return the running event loop.  Raise a RuntimeError if there is none.
        3182                 :            :
        3183                 :            : This function is thread-specific.
        3184                 :            : [clinic start generated code]*/
        3185                 :            :
        3186                 :            : static PyObject *
        3187                 :          0 : _asyncio_get_running_loop_impl(PyObject *module)
        3188                 :            : /*[clinic end generated code: output=c247b5f9e529530e input=2a3bf02ba39f173d]*/
        3189                 :            : {
        3190                 :            :     PyObject *loop;
        3191                 :          0 :     asyncio_state *state = get_asyncio_state(module);
        3192         [ #  # ]:          0 :     if (get_running_loop(state, &loop)) {
        3193                 :          0 :         return NULL;
        3194                 :            :     }
        3195         [ #  # ]:          0 :     if (loop == NULL) {
        3196                 :            :         /* There's no currently running event loop */
        3197                 :          0 :         PyErr_SetString(
        3198                 :            :             PyExc_RuntimeError, "no running event loop");
        3199                 :            :     }
        3200                 :          0 :     return loop;
        3201                 :            : }
        3202                 :            :
        3203                 :            : /*[clinic input]
        3204                 :            : _asyncio._register_task
        3205                 :            :
        3206                 :            :     task: object
        3207                 :            :
        3208                 :            : Register a new task in asyncio as executed by loop.
        3209                 :            :
        3210                 :            : Returns None.
        3211                 :            : [clinic start generated code]*/
        3212                 :            :
        3213                 :            : static PyObject *
        3214                 :          0 : _asyncio__register_task_impl(PyObject *module, PyObject *task)
        3215                 :            : /*[clinic end generated code: output=8672dadd69a7d4e2 input=21075aaea14dfbad]*/
        3216                 :            : {
        3217                 :          0 :     asyncio_state *state = get_asyncio_state(module);
        3218         [ #  # ]:          0 :     if (register_task(state, task) < 0) {
        3219                 :          0 :         return NULL;
        3220                 :            :     }
        3221                 :          0 :     Py_RETURN_NONE;
        3222                 :            : }
        3223                 :            :
        3224                 :            :
        3225                 :            : /*[clinic input]
        3226                 :            : _asyncio._unregister_task
        3227                 :            :
        3228                 :            :     task: object
        3229                 :            :
        3230                 :            : Unregister a task.
        3231                 :            :
        3232                 :            : Returns None.
        3233                 :            : [clinic start generated code]*/
        3234                 :            :
        3235                 :            : static PyObject *
        3236                 :          0 : _asyncio__unregister_task_impl(PyObject *module, PyObject *task)
        3237                 :            : /*[clinic end generated code: output=6e5585706d568a46 input=28fb98c3975f7bdc]*/
        3238                 :            : {
        3239                 :          0 :     asyncio_state *state = get_asyncio_state(module);
        3240         [ #  # ]:          0 :     if (unregister_task(state, task) < 0) {
        3241                 :          0 :         return NULL;
        3242                 :            :     }
        3243                 :          0 :     Py_RETURN_NONE;
        3244                 :            : }
        3245                 :            :
        3246                 :            :
        3247                 :            : /*[clinic input]
        3248                 :            : _asyncio._enter_task
        3249                 :            :
        3250                 :            :     loop: object
        3251                 :            :     task: object
        3252                 :            :
        3253                 :            : Enter into task execution or resume suspended task.
        3254                 :            :
        3255                 :            : Task belongs to loop.
        3256                 :            :
        3257                 :            : Returns None.
        3258                 :            : [clinic start generated code]*/
        3259                 :            :
        3260                 :            : static PyObject *
        3261                 :          0 : _asyncio__enter_task_impl(PyObject *module, PyObject *loop, PyObject *task)
        3262                 :            : /*[clinic end generated code: output=a22611c858035b73 input=de1b06dca70d8737]*/
        3263                 :            : {
        3264                 :          0 :     asyncio_state *state = get_asyncio_state(module);
        3265         [ #  # ]:          0 :     if (enter_task(state, loop, task) < 0) {
        3266                 :          0 :         return NULL;
        3267                 :            :     }
        3268                 :          0 :     Py_RETURN_NONE;
        3269                 :            : }
        3270                 :            :
        3271                 :            :
        3272                 :            : /*[clinic input]
        3273                 :            : _asyncio._leave_task
        3274                 :            :
        3275                 :            :     loop: object
        3276                 :            :     task: object
        3277                 :            :
        3278                 :            : Leave task execution or suspend a task.
        3279                 :            :
        3280                 :            : Task belongs to loop.
        3281                 :            :
        3282                 :            : Returns None.
        3283                 :            : [clinic start generated code]*/
        3284                 :            :
        3285                 :            : static PyObject *
        3286                 :          0 : _asyncio__leave_task_impl(PyObject *module, PyObject *loop, PyObject *task)
        3287                 :            : /*[clinic end generated code: output=0ebf6db4b858fb41 input=51296a46313d1ad8]*/
        3288                 :            : {
        3289                 :          0 :     asyncio_state *state = get_asyncio_state(module);
        3290         [ #  # ]:          0 :     if (leave_task(state, loop, task) < 0) {
        3291                 :          0 :         return NULL;
        3292                 :            :     }
        3293                 :          0 :     Py_RETURN_NONE;
        3294                 :            : }
        3295                 :            :
        3296                 :            :
        3297                 :            : /*[clinic input]
        3298                 :            : _asyncio.current_task
        3299                 :            :
        3300                 :            :     loop: object = None
        3301                 :            :
        3302                 :            : Return a currently executed task.
        3303                 :            :
        3304                 :            : [clinic start generated code]*/
        3305                 :            :
        3306                 :            : static PyObject *
        3307                 :          0 : _asyncio_current_task_impl(PyObject *module, PyObject *loop)
        3308                 :            : /*[clinic end generated code: output=fe15ac331a7f981a input=58910f61a5627112]*/
        3309                 :            : {
        3310                 :            :     PyObject *ret;
        3311                 :          0 :     asyncio_state *state = get_asyncio_state(module);
        3312                 :            :
        3313         [ #  # ]:          0 :     if (loop == Py_None) {
        3314                 :          0 :         loop = _asyncio_get_running_loop_impl(module);
        3315         [ #  # ]:          0 :         if (loop == NULL) {
        3316                 :          0 :             return NULL;
        3317                 :            :         }
        3318                 :            :     } else {
        3319                 :          0 :         Py_INCREF(loop);
        3320                 :            :     }
        3321                 :            :
        3322                 :          0 :     ret = PyDict_GetItemWithError(state->current_tasks, loop);
        3323                 :          0 :     Py_DECREF(loop);
        3324   [ #  #  #  # ]:          0 :     if (ret == NULL && PyErr_Occurred()) {
        3325                 :          0 :         return NULL;
        3326                 :            :     }
        3327         [ #  # ]:          0 :     else if (ret == NULL) {
        3328                 :          0 :         Py_RETURN_NONE;
        3329                 :            :     }
        3330                 :          0 :     Py_INCREF(ret);
        3331                 :          0 :     return ret;
        3332                 :            : }
        3333                 :            :
        3334                 :            :
        3335                 :            : /*********************** Module **************************/
        3336                 :            :
        3337                 :            :
        3338                 :            : static void
        3339                 :          2 : module_free_freelists(void)
        3340                 :            : {
        3341                 :            :     PyObject *next;
        3342                 :            :     PyObject *current;
        3343                 :            :
        3344                 :          2 :     next = (PyObject*) fi_freelist;
        3345         [ -  + ]:          2 :     while (next != NULL) {
        3346                 :            :         assert(fi_freelist_len > 0);
        3347                 :          0 :         fi_freelist_len--;
        3348                 :            :
        3349                 :          0 :         current = next;
        3350                 :          0 :         next = (PyObject*) ((futureiterobject*) current)->future;
        3351                 :          0 :         PyObject_GC_Del(current);
        3352                 :            :     }
        3353                 :            :     assert(fi_freelist_len == 0);
        3354                 :          2 :     fi_freelist = NULL;
        3355                 :          2 : }
        3356                 :            :
        3357                 :            : static int
        3358                 :         10 : module_traverse(PyObject *mod, visitproc visit, void *arg)
        3359                 :            : {
        3360                 :         10 :     asyncio_state *state = get_asyncio_state(mod);
        3361                 :            :
        3362   [ +  -  -  + ]:         10 :     Py_VISIT(state->FutureIterType);
        3363   [ +  -  -  + ]:         10 :     Py_VISIT(state->TaskStepMethWrapper_Type);
        3364   [ +  -  -  + ]:         10 :     Py_VISIT(state->FutureType);
        3365   [ +  -  -  + ]:         10 :     Py_VISIT(state->TaskType);
        3366                 :            :
        3367   [ +  +  -  + ]:         10 :     Py_VISIT(state->asyncio_mod);
        3368   [ +  +  -  + ]:         10 :     Py_VISIT(state->traceback_extract_stack);
        3369   [ +  +  -  + ]:         10 :     Py_VISIT(state->asyncio_future_repr_func);
        3370   [ +  +  -  + ]:         10 :     Py_VISIT(state->asyncio_get_event_loop_policy);
        3371   [ +  +  -  + ]:         10 :     Py_VISIT(state->asyncio_iscoroutine_func);
        3372   [ +  +  -  + ]:         10 :     Py_VISIT(state->asyncio_task_get_stack_func);
        3373   [ +  +  -  + ]:         10 :     Py_VISIT(state->asyncio_task_print_stack_func);
        3374   [ +  +  -  + ]:         10 :     Py_VISIT(state->asyncio_task_repr_func);
        3375   [ +  +  -  + ]:         10 :     Py_VISIT(state->asyncio_InvalidStateError);
        3376   [ +  +  -  + ]:         10 :     Py_VISIT(state->asyncio_CancelledError);
        3377                 :            :
        3378   [ +  +  -  + ]:         10 :     Py_VISIT(state->all_tasks);
        3379   [ +  +  -  + ]:         10 :     Py_VISIT(state->current_tasks);
        3380   [ +  +  -  + ]:         10 :     Py_VISIT(state->iscoroutine_typecache);
        3381                 :            :
        3382   [ +  +  -  + ]:         10 :     Py_VISIT(state->context_kwname);
        3383                 :            :
        3384                 :            :     // Visit freelist.
        3385                 :         10 :     PyObject *next = (PyObject*) fi_freelist;
        3386         [ -  + ]:         10 :     while (next != NULL) {
        3387                 :          0 :         PyObject *current = next;
        3388   [ #  #  #  # ]:          0 :         Py_VISIT(current);
        3389                 :          0 :         next = (PyObject*) ((futureiterobject*) current)->future;
        3390                 :            :     }
        3391                 :         10 :     return 0;
        3392                 :            : }
        3393                 :            :
        3394                 :            : static int
        3395                 :          2 : module_clear(PyObject *mod)
        3396                 :            : {
        3397                 :          2 :     asyncio_state *state = get_asyncio_state(mod);
        3398                 :            :
        3399         [ +  + ]:          2 :     Py_CLEAR(state->FutureIterType);
        3400         [ +  + ]:          2 :     Py_CLEAR(state->TaskStepMethWrapper_Type);
        3401         [ +  + ]:          2 :     Py_CLEAR(state->FutureType);
        3402         [ +  + ]:          2 :     Py_CLEAR(state->TaskType);
        3403                 :            :
        3404         [ +  + ]:          2 :     Py_CLEAR(state->asyncio_mod);
        3405         [ +  + ]:          2 :     Py_CLEAR(state->traceback_extract_stack);
        3406         [ +  + ]:          2 :     Py_CLEAR(state->asyncio_future_repr_func);
        3407         [ +  + ]:          2 :     Py_CLEAR(state->asyncio_get_event_loop_policy);
        3408         [ +  + ]:          2 :     Py_CLEAR(state->asyncio_iscoroutine_func);
        3409         [ +  + ]:          2 :     Py_CLEAR(state->asyncio_task_get_stack_func);
        3410         [ +  + ]:          2 :     Py_CLEAR(state->asyncio_task_print_stack_func);
        3411         [ +  + ]:          2 :     Py_CLEAR(state->asyncio_task_repr_func);
        3412         [ +  + ]:          2 :     Py_CLEAR(state->asyncio_InvalidStateError);
        3413         [ +  + ]:          2 :     Py_CLEAR(state->asyncio_CancelledError);
        3414                 :            :
        3415         [ +  + ]:          2 :     Py_CLEAR(state->all_tasks);
        3416         [ +  + ]:          2 :     Py_CLEAR(state->current_tasks);
        3417         [ +  + ]:          2 :     Py_CLEAR(state->iscoroutine_typecache);
        3418                 :            :
        3419         [ +  + ]:          2 :     Py_CLEAR(state->context_kwname);
        3420                 :            :
        3421                 :          2 :     module_free_freelists();
        3422                 :            :
        3423                 :          2 :     return 0;
        3424                 :            : }
        3425                 :            :
        3426                 :            : static void
        3427                 :          1 : module_free(void *mod)
        3428                 :            : {
        3429                 :          1 :     (void)module_clear((PyObject *)mod);
        3430                 :          1 : }
        3431                 :            :
        3432                 :            : static int
        3433                 :          1 : module_init(asyncio_state *state)
        3434                 :            : {
        3435                 :          1 :     PyObject *module = NULL;
        3436                 :            :
        3437                 :          1 :     state->asyncio_mod = PyImport_ImportModule("asyncio");
        3438         [ -  + ]:          1 :     if (state->asyncio_mod == NULL) {
        3439                 :          0 :         goto fail;
        3440                 :            :     }
        3441                 :            :
        3442                 :          1 :     state->current_tasks = PyDict_New();
        3443         [ -  + ]:          1 :     if (state->current_tasks == NULL) {
        3444                 :          0 :         goto fail;
        3445                 :            :     }
        3446                 :            :
        3447                 :          1 :     state->iscoroutine_typecache = PySet_New(NULL);
        3448         [ -  + ]:          1 :     if (state->iscoroutine_typecache == NULL) {
        3449                 :          0 :         goto fail;
        3450                 :            :     }
        3451                 :            :
        3452                 :            :
        3453                 :          1 :     state->context_kwname = Py_BuildValue("(s)", "context");
        3454         [ -  + ]:          1 :     if (state->context_kwname == NULL) {
        3455                 :          0 :         goto fail;
        3456                 :            :     }
        3457                 :            :
        3458                 :            : #define WITH_MOD(NAME) \
        3459                 :            :     Py_CLEAR(module); \
        3460                 :            :     module = PyImport_ImportModule(NAME); \
        3461                 :            :     if (module == NULL) { \
        3462                 :            :         goto fail; \
        3463                 :            :     }
        3464                 :            :
        3465                 :            : #define GET_MOD_ATTR(VAR, NAME) \
        3466                 :            :     VAR = PyObject_GetAttrString(module, NAME); \
        3467                 :            :     if (VAR == NULL) { \
        3468                 :            :         goto fail; \
        3469                 :            :     }
        3470                 :            :
        3471   [ -  +  -  + ]:          1 :     WITH_MOD("asyncio.events")
        3472         [ -  + ]:          1 :     GET_MOD_ATTR(state->asyncio_get_event_loop_policy, "get_event_loop_policy")
        3473                 :            :
        3474   [ +  -  -  + ]:          1 :     WITH_MOD("asyncio.base_futures")
        3475         [ -  + ]:          1 :     GET_MOD_ATTR(state->asyncio_future_repr_func, "_future_repr")
        3476                 :            :
        3477   [ +  -  -  + ]:          1 :     WITH_MOD("asyncio.exceptions")
        3478         [ -  + ]:          1 :     GET_MOD_ATTR(state->asyncio_InvalidStateError, "InvalidStateError")
        3479         [ -  + ]:          1 :     GET_MOD_ATTR(state->asyncio_CancelledError, "CancelledError")
        3480                 :            :
        3481   [ +  -  -  + ]:          1 :     WITH_MOD("asyncio.base_tasks")
        3482         [ -  + ]:          1 :     GET_MOD_ATTR(state->asyncio_task_repr_func, "_task_repr")
        3483         [ -  + ]:          1 :     GET_MOD_ATTR(state->asyncio_task_get_stack_func, "_task_get_stack")
        3484         [ -  + ]:          1 :     GET_MOD_ATTR(state->asyncio_task_print_stack_func, "_task_print_stack")
        3485                 :            :
        3486   [ +  -  -  + ]:          1 :     WITH_MOD("asyncio.coroutines")
        3487         [ -  + ]:          1 :     GET_MOD_ATTR(state->asyncio_iscoroutine_func, "iscoroutine")
        3488                 :            :
        3489   [ +  -  -  + ]:          1 :     WITH_MOD("traceback")
        3490         [ -  + ]:          1 :     GET_MOD_ATTR(state->traceback_extract_stack, "extract_stack")
        3491                 :            :
        3492                 :            :     PyObject *weak_set;
        3493   [ +  -  -  + ]:          1 :     WITH_MOD("weakref")
        3494         [ -  + ]:          1 :     GET_MOD_ATTR(weak_set, "WeakSet");
        3495                 :          1 :     state->all_tasks = PyObject_CallNoArgs(weak_set);
        3496         [ +  - ]:          1 :     Py_CLEAR(weak_set);
        3497         [ -  + ]:          1 :     if (state->all_tasks == NULL) {
        3498                 :          0 :         goto fail;
        3499                 :            :     }
        3500                 :            :
        3501                 :          1 :     Py_DECREF(module);
        3502                 :          1 :     return 0;
        3503                 :            :
        3504                 :          0 : fail:
        3505         [ #  # ]:          0 :     Py_CLEAR(module);
        3506                 :          0 :     return -1;
        3507                 :            :
        3508                 :            : #undef WITH_MOD
        3509                 :            : #undef GET_MOD_ATTR
        3510                 :            : }
        3511                 :            :
        3512                 :            : PyDoc_STRVAR(module_doc, "Accelerator module for asyncio");
        3513                 :            :
        3514                 :            : static PyMethodDef asyncio_methods[] = {
        3515                 :            :     _ASYNCIO_CURRENT_TASK_METHODDEF
        3516                 :            :     _ASYNCIO_GET_EVENT_LOOP_METHODDEF
        3517                 :            :     _ASYNCIO_GET_RUNNING_LOOP_METHODDEF
        3518                 :            :     _ASYNCIO__GET_RUNNING_LOOP_METHODDEF
        3519                 :            :     _ASYNCIO__SET_RUNNING_LOOP_METHODDEF
        3520                 :            :     _ASYNCIO__REGISTER_TASK_METHODDEF
        3521                 :            :     _ASYNCIO__UNREGISTER_TASK_METHODDEF
        3522                 :            :     _ASYNCIO__ENTER_TASK_METHODDEF
        3523                 :            :     _ASYNCIO__LEAVE_TASK_METHODDEF
        3524                 :            :     {NULL, NULL}
        3525                 :            : };
        3526                 :            :
        3527                 :            : static int
        3528                 :          1 : module_exec(PyObject *mod)
        3529                 :            : {
        3530                 :          1 :     asyncio_state *state = get_asyncio_state(mod);
        3531                 :            :
        3532                 :            : #define CREATE_TYPE(m, tp, spec, base)                                  \
        3533                 :            :     do {                                                                \
        3534                 :            :         tp = (PyTypeObject *)PyType_FromMetaclass(NULL, m, spec,        \
        3535                 :            :                                                   (PyObject *)base);    \
        3536                 :            :         if (tp == NULL) {                                               \
        3537                 :            :             return -1;                                                  \
        3538                 :            :         }                                                               \
        3539                 :            :     } while (0)
        3540                 :            :
        3541         [ -  + ]:          1 :     CREATE_TYPE(mod, state->TaskStepMethWrapper_Type, &TaskStepMethWrapper_spec, NULL);
        3542         [ -  + ]:          1 :     CREATE_TYPE(mod, state->FutureIterType, &FutureIter_spec, NULL);
        3543         [ -  + ]:          1 :     CREATE_TYPE(mod, state->FutureType, &Future_spec, NULL);
        3544         [ -  + ]:          1 :     CREATE_TYPE(mod, state->TaskType, &Task_spec, state->FutureType);
        3545                 :            :
        3546                 :            : #undef CREATE_TYPE
        3547                 :            :
        3548         [ -  + ]:          1 :     if (PyModule_AddType(mod, state->FutureType) < 0) {
        3549                 :          0 :         return -1;
        3550                 :            :     }
        3551                 :            :
        3552         [ -  + ]:          1 :     if (PyModule_AddType(mod, state->TaskType) < 0) {
        3553                 :          0 :         return -1;
        3554                 :            :     }
        3555                 :            :     // Must be done after types are added to avoid a circular dependency
        3556         [ -  + ]:          1 :     if (module_init(state) < 0) {
        3557                 :          0 :         return -1;
        3558                 :            :     }
        3559                 :            :
        3560         [ -  + ]:          1 :     if (PyModule_AddObjectRef(mod, "_all_tasks", state->all_tasks) < 0) {
        3561                 :          0 :         return -1;
        3562                 :            :     }
        3563                 :            :
        3564         [ -  + ]:          1 :     if (PyModule_AddObjectRef(mod, "_current_tasks", state->current_tasks) < 0) {
        3565                 :          0 :         return -1;
        3566                 :            :     }
        3567                 :            :
        3568                 :            :
        3569                 :          1 :     return 0;
        3570                 :            : }
        3571                 :            :
        3572                 :            : static struct PyModuleDef_Slot module_slots[] = {
        3573                 :            :     {Py_mod_exec, module_exec},
        3574                 :            :     {0, NULL},
        3575                 :            : };
        3576                 :            :
        3577                 :            : static struct PyModuleDef _asynciomodule = {
        3578                 :            :     .m_base = PyModuleDef_HEAD_INIT,
        3579                 :            :     .m_name = "_asyncio",
        3580                 :            :     .m_doc = module_doc,
        3581                 :            :     .m_size = sizeof(asyncio_state),
        3582                 :            :     .m_methods = asyncio_methods,
        3583                 :            :     .m_slots = module_slots,
        3584                 :            :     .m_traverse = module_traverse,
        3585                 :            :     .m_clear = module_clear,
        3586                 :            :     .m_free = (freefunc)module_free,
        3587                 :            : };
        3588                 :            :
        3589                 :            : PyMODINIT_FUNC
        3590                 :          1 : PyInit__asyncio(void)
        3591                 :            : {
        3592                 :          1 :     return PyModuleDef_Init(&_asynciomodule);
        3593                 :            : }

Generated by: LCOV version 1.14