/* Generator object implementation */

#include "Python.h"

#include "frameobject.h"

#include "structmember.h"

#include "opcode.h"

static PyObject *gen_close(PyGenObject *, PyObject *);

static PyObject *async_gen_asend_new(PyAsyncGenObject *, PyObject *);

static PyObject *async_gen_athrow_new(PyAsyncGenObject *, PyObject *);

static char *NON_INIT_CORO_MSG = "can't send non-None value to a "

                                 "just-started coroutine";

static char *ASYNC_GEN_IGNORED_EXIT_MSG =

                                 "async generator ignored GeneratorExit";

static int

gen_traverse(PyGenObject *gen, visitproc visit, void *arg)

{

    Py_VISIT((PyObject *)gen->gi_frame);

    Py_VISIT(gen->gi_code);

    Py_VISIT(gen->gi_name);

    Py_VISIT(gen->gi_qualname);

    return 0;

}

void

_PyGen_Finalize(PyObject *self)

{

    PyGenObject *gen = (PyGenObject *)self;

    PyObject *res = NULL;

    PyObject *error_type, *error_value, *error_traceback;

    if (gen->gi_frame == NULL || gen->gi_frame->f_stacktop == NULL)

        /* Generator isn't paused, so no need to close */

        return;

    if (PyAsyncGen_CheckExact(self)) {

        PyAsyncGenObject *agen = (PyAsyncGenObject*)self;

        PyObject *finalizer = agen->ag_finalizer;

        if (finalizer && !agen->ag_closed) {

            /* Save the current exception, if any. */

            PyErr_Fetch(&error_type, &error_value, &error_traceback);

            res = PyObject_CallFunctionObjArgs(finalizer, self, NULL);

            if (res == NULL) {

                PyErr_WriteUnraisable(self);

            } else {

                Py_DECREF(res);

            }

            /* Restore the saved exception. */

            PyErr_Restore(error_type, error_value, error_traceback);

            return;

        }

    }

    /* Save the current exception, if any. */

    PyErr_Fetch(&error_type, &error_value, &error_traceback);

    /* If `gen` is a coroutine, and if it was never awaited on,

       issue a RuntimeWarning. */

    if (gen->gi_code != NULL &&

        ((PyCodeObject *)gen->gi_code)->co_flags & CO_COROUTINE &&

        gen->gi_frame->f_lasti == -1) {

        if (!error_value) {

            PyErr_WarnFormat(PyExc_RuntimeWarning, 1,

                             "coroutine '%.50S' was never awaited",

                             gen->gi_qualname);

        }

    }

    else {

        res = gen_close(gen, NULL);

    }

    if (res == NULL) {

        if (PyErr_Occurred())

            PyErr_WriteUnraisable(self);

    }

    else {

        Py_DECREF(res);

    }

    /* Restore the saved exception. */

    PyErr_Restore(error_type, error_value, error_traceback);

}

static void

gen_dealloc(PyGenObject *gen)

{

    PyObject *self = (PyObject *) gen;

    _PyObject_GC_UNTRACK(gen);

    if (gen->gi_weakreflist != NULL)

        PyObject_ClearWeakRefs(self);

    _PyObject_GC_TRACK(self);

    if (PyObject_CallFinalizerFromDealloc(self))

        return;                     /* resurrected.  :( */

    _PyObject_GC_UNTRACK(self);

    if (PyAsyncGen_CheckExact(gen)) {

        /* We have to handle this case for asynchronous generators

           right here, because this code has to be between UNTRACK

           and GC_Del. */

        Py_CLEAR(((PyAsyncGenObject*)gen)->ag_finalizer);

    }

    if (gen->gi_frame != NULL) {

        gen->gi_frame->f_gen = NULL;

        Py_CLEAR(gen->gi_frame);

    }

    Py_CLEAR(gen->gi_code);

    Py_CLEAR(gen->gi_name);

    Py_CLEAR(gen->gi_qualname);

    PyObject_GC_Del(gen);

}

static PyObject *

gen_send_ex(PyGenObject *gen, PyObject *arg, int exc, int closing)

{

    PyThreadState *tstate = PyThreadState_GET();

    PyFrameObject *f = gen->gi_frame;

    PyObject *result;

    if (gen->gi_running) {

        char *msg = "generator already executing";

        if (PyCoro_CheckExact(gen)) {

            msg = "coroutine already executing";

        }

        else if (PyAsyncGen_CheckExact(gen)) {

            msg = "async generator already executing";

        }

        PyErr_SetString(PyExc_ValueError, msg);

        return NULL;

    }

    if (f == NULL || f->f_stacktop == NULL) {

        if (PyCoro_CheckExact(gen) && !closing) {

            /* `gen` is an exhausted coroutine: raise an error,

               except when called from gen_close(), which should

               always be a silent method. */

            PyErr_SetString(

                PyExc_RuntimeError,

                "cannot reuse already awaited coroutine");

        }

        else if (arg && !exc) {

            /* `gen` is an exhausted generator:

               only set exception if called from send(). */

            if (PyAsyncGen_CheckExact(gen)) {

                PyErr_SetNone(PyExc_StopAsyncIteration);

            }

            else {

                PyErr_SetNone(PyExc_StopIteration);

            }

        }

        return NULL;

    }

    if (f->f_lasti == -1) {

        if (arg && arg != Py_None) {

            char *msg = "can't send non-None value to a "

                        "just-started generator";

            if (PyCoro_CheckExact(gen)) {

                msg = NON_INIT_CORO_MSG;

            }

            else if (PyAsyncGen_CheckExact(gen)) {

                msg = "can't send non-None value to a "

                      "just-started async generator";

            }

            PyErr_SetString(PyExc_TypeError, msg);

            return NULL;

        }

    } else {

        /* Push arg onto the frame's value stack */

        result = arg ? arg : Py_None;

        Py_INCREF(result);

        *(f->f_stacktop++) = result;

    }

    /* Generators always return to their most recent caller, not

     * necessarily their creator. */

    Py_XINCREF(tstate->frame);

    assert(f->f_back == NULL);

    f->f_back = tstate->frame;

    gen->gi_running = 1;

    result = PyEval_EvalFrameEx(f, exc);

    gen->gi_running = 0;

    /* Don't keep the reference to f_back any longer than necessary.  It

     * may keep a chain of frames alive or it could create a reference

     * cycle. */

    assert(f->f_back == tstate->frame);

    Py_CLEAR(f->f_back);

    /* If the generator just returned (as opposed to yielding), signal

     * that the generator is exhausted. */

    if (result && f->f_stacktop == NULL) {

        if (result == Py_None) {

            /* Delay exception instantiation if we can */

            if (PyAsyncGen_CheckExact(gen)) {

                PyErr_SetNone(PyExc_StopAsyncIteration);

            }

            else {

                PyErr_SetNone(PyExc_StopIteration);

            }

        }

        else {

            /* Async generators cannot return anything but None */

            assert(!PyAsyncGen_CheckExact(gen));

            _PyGen_SetStopIterationValue(result);

        }

        Py_CLEAR(result);

    }

    else if (!result && PyErr_ExceptionMatches(PyExc_StopIteration)) {

        /* Check for __future__ generator_stop and conditionally turn

         * a leaking StopIteration into RuntimeError (with its cause

         * set appropriately). */

        const int check_stop_iter_error_flags = CO_FUTURE_GENERATOR_STOP |

                                                CO_COROUTINE |

                                                CO_ITERABLE_COROUTINE |

                                                CO_ASYNC_GENERATOR;

        if (gen->gi_code != NULL &&

            ((PyCodeObject *)gen->gi_code)->co_flags &

                check_stop_iter_error_flags)

        {

            /* `gen` is either:

                  * a generator with CO_FUTURE_GENERATOR_STOP flag;

                  * a coroutine;

                  * a generator with CO_ITERABLE_COROUTINE flag

                    (decorated with types.coroutine decorator);

                  * an async generator.

            */

            const char *msg = "generator raised StopIteration";

            if (PyCoro_CheckExact(gen)) {

                msg = "coroutine raised StopIteration";

            }

            else if PyAsyncGen_CheckExact(gen) {

                msg = "async generator raised StopIteration";

            }

            _PyErr_FormatFromCause(PyExc_RuntimeError, "%s", msg);

        }

        else {

            /* `gen` is an ordinary generator without

               CO_FUTURE_GENERATOR_STOP flag.

            */

            PyObject *exc, *val, *tb;

            /* Pop the exception before issuing a warning. */

            PyErr_Fetch(&exc, &val, &tb);

            if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,

                                 "generator '%.50S' raised StopIteration",

                                 gen->gi_qualname)) {

                /* Warning was converted to an error. */

                Py_XDECREF(exc);

                Py_XDECREF(val);

                Py_XDECREF(tb);

            }

            else {

                PyErr_Restore(exc, val, tb);

            }

        }

    }

    else if (PyAsyncGen_CheckExact(gen) && !result &&

             PyErr_ExceptionMatches(PyExc_StopAsyncIteration))

    {

        /* code in `gen` raised a StopAsyncIteration error:

           raise a RuntimeError.

        */

        const char *msg = "async generator raised StopAsyncIteration";

        _PyErr_FormatFromCause(PyExc_RuntimeError, "%s", msg);

    }

    if (!result || f->f_stacktop == NULL) {

        /* generator can't be rerun, so release the frame */

        /* first clean reference cycle through stored exception traceback */

        PyObject *t, *v, *tb;

        t = f->f_exc_type;

        v = f->f_exc_value;

        tb = f->f_exc_traceback;

        f->f_exc_type = NULL;

        f->f_exc_value = NULL;

        f->f_exc_traceback = NULL;

        Py_XDECREF(t);

        Py_XDECREF(v);

        Py_XDECREF(tb);

        gen->gi_frame->f_gen = NULL;

        gen->gi_frame = NULL;

        Py_DECREF(f);

    }

    return result;

}

PyDoc_STRVAR(send_doc,

"send(arg) -> send 'arg' into generator,\n\

return next yielded value or raise StopIteration.");

PyObject *

_PyGen_Send(PyGenObject *gen, PyObject *arg)

{

    return gen_send_ex(gen, arg, 0, 0);

}

PyDoc_STRVAR(close_doc,

"close() -> raise GeneratorExit inside generator.");

/*

 *   This helper function is used by gen_close and gen_throw to

 *   close a subiterator being delegated to by yield-from.

 */

static int

gen_close_iter(PyObject *yf)

{

    PyObject *retval = NULL;

    _Py_IDENTIFIER(close);

    if (PyGen_CheckExact(yf) || PyCoro_CheckExact(yf)) {

        retval = gen_close((PyGenObject *)yf, NULL);

        if (retval == NULL)

            return -1;

    }

    else {

        PyObject *meth = _PyObject_GetAttrId(yf, &PyId_close);

        if (meth == NULL) {

            if (!PyErr_ExceptionMatches(PyExc_AttributeError))

                PyErr_WriteUnraisable(yf);

            PyErr_Clear();

        }

        else {

            retval = _PyObject_CallNoArg(meth);

            Py_DECREF(meth);

            if (retval == NULL)

                return -1;

        }

    }

    Py_XDECREF(retval);

    return 0;

}

PyObject *

_PyGen_yf(PyGenObject *gen)

{

    PyObject *yf = NULL;

    PyFrameObject *f = gen->gi_frame;

    if (f && f->f_stacktop) {

        PyObject *bytecode = f->f_code->co_code;

        unsigned char *code = (unsigned char *)PyBytes_AS_STRING(bytecode);

        if (f->f_lasti < 0) {

            /* Return immediately if the frame didn't start yet. YIELD_FROM

               always come after LOAD_CONST: a code object should not start

               with YIELD_FROM */

            assert(code[0] != YIELD_FROM);

            return NULL;

        }

        if (code[f->f_lasti + sizeof(_Py_CODEUNIT)] != YIELD_FROM)

            return NULL;

        yf = f->f_stacktop[-1];

        Py_INCREF(yf);

    }

    return yf;

}

static PyObject *

gen_close(PyGenObject *gen, PyObject *args)

{

    PyObject *retval;

    PyObject *yf = _PyGen_yf(gen);

    int err = 0;

    if (yf) {

        gen->gi_running = 1;

        err = gen_close_iter(yf);

        gen->gi_running = 0;

        Py_DECREF(yf);

    }

    if (err == 0)

        PyErr_SetNone(PyExc_GeneratorExit);

    retval = gen_send_ex(gen, Py_None, 1, 1);

    if (retval) {

        char *msg = "generator ignored GeneratorExit";

        if (PyCoro_CheckExact(gen)) {

            msg = "coroutine ignored GeneratorExit";

        } else if (PyAsyncGen_CheckExact(gen)) {

            msg = ASYNC_GEN_IGNORED_EXIT_MSG;

        }

        Py_DECREF(retval);

        PyErr_SetString(PyExc_RuntimeError, msg);

        return NULL;

    }

    if (PyErr_ExceptionMatches(PyExc_StopIteration)

        || PyErr_ExceptionMatches(PyExc_GeneratorExit)) {

        PyErr_Clear();          /* ignore these errors */

        Py_INCREF(Py_None);

        return Py_None;

    }

    return NULL;

}

PyDoc_STRVAR(throw_doc,

"throw(typ[,val[,tb]]) -> raise exception in generator,\n\

return next yielded value or raise StopIteration.");

static PyObject *

_gen_throw(PyGenObject *gen, int close_on_genexit,

           PyObject *typ, PyObject *val, PyObject *tb)

{

    PyObject *yf = _PyGen_yf(gen);

    _Py_IDENTIFIER(throw);

    if (yf) {

        PyObject *ret;

        int err;

        if (PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit) &&

            close_on_genexit

        ) {

            /* Asynchronous generators *should not* be closed right away.

               We have to allow some awaits to work it through, hence the

               `close_on_genexit` parameter here.

            */

            gen->gi_running = 1;

            err = gen_close_iter(yf);

            gen->gi_running = 0;

            Py_DECREF(yf);

            if (err < 0)

                return gen_send_ex(gen, Py_None, 1, 0);

            goto throw_here;

        }

        if (PyGen_CheckExact(yf) || PyCoro_CheckExact(yf)) {

            /* `yf` is a generator or a coroutine. */

            gen->gi_running = 1;

            /* Close the generator that we are currently iterating with

               'yield from' or awaiting on with 'await'. */

            ret = _gen_throw((PyGenObject *)yf, close_on_genexit,

                             typ, val, tb);

            gen->gi_running = 0;

        } else {

            /* `yf` is an iterator or a coroutine-like object. */

            PyObject *meth = _PyObject_GetAttrId(yf, &PyId_throw);

            if (meth == NULL) {

                if (!PyErr_ExceptionMatches(PyExc_AttributeError)) {

                    Py_DECREF(yf);

                    return NULL;

                }

                PyErr_Clear();

                Py_DECREF(yf);

                goto throw_here;

            }

            gen->gi_running = 1;

            ret = PyObject_CallFunctionObjArgs(meth, typ, val, tb, NULL);

            gen->gi_running = 0;

            Py_DECREF(meth);

        }

        Py_DECREF(yf);

        if (!ret) {

            PyObject *val;

            /* Pop subiterator from stack */

            ret = *(--gen->gi_frame->f_stacktop);

            assert(ret == yf);

            Py_DECREF(ret);

            /* Termination repetition of YIELD_FROM */

            assert(gen->gi_frame->f_lasti >= 0);

            gen->gi_frame->f_lasti += sizeof(_Py_CODEUNIT);

            if (_PyGen_FetchStopIterationValue(&val) == 0) {

                ret = gen_send_ex(gen, val, 0, 0);

                Py_DECREF(val);

            } else {

                ret = gen_send_ex(gen, Py_None, 1, 0);

            }

        }

        return ret;

    }

throw_here:

    /* First, check the traceback argument, replacing None with

       NULL. */

    if (tb == Py_None) {

        tb = NULL;

    }

    else if (tb != NULL && !PyTraceBack_Check(tb)) {

        PyErr_SetString(PyExc_TypeError,

            "throw() third argument must be a traceback object");

        return NULL;

    }

    Py_INCREF(typ);

    Py_XINCREF(val);

    Py_XINCREF(tb);

    if (PyExceptionClass_Check(typ))

        PyErr_NormalizeException(&typ, &val, &tb);

    else if (PyExceptionInstance_Check(typ)) {

        /* Raising an instance.  The value should be a dummy. */

        if (val && val != Py_None) {

            PyErr_SetString(PyExc_TypeError,

              "instance exception may not have a separate value");

            goto failed_throw;

        }

        else {

            /* Normalize to raise <class>, <instance> */

            Py_XDECREF(val);

            val = typ;

            typ = PyExceptionInstance_Class(typ);

            Py_INCREF(typ);

            if (tb == NULL)

                /* Returns NULL if there's no traceback */

                tb = PyException_GetTraceback(val);

        }

    }

    else {

        /* Not something you can raise.  throw() fails. */

        PyErr_Format(PyExc_TypeError,

                     "exceptions must be classes or instances "

                     "deriving from BaseException, not %s",

                     Py_TYPE(typ)->tp_name);

            goto failed_throw;

    }

    PyErr_Restore(typ, val, tb);

    return gen_send_ex(gen, Py_None, 1, 0);

failed_throw:

    /* Didn't use our arguments, so restore their original refcounts */

    Py_DECREF(typ);

    Py_XDECREF(val);

    Py_XDECREF(tb);

    return NULL;

}

static PyObject *

gen_throw(PyGenObject *gen, PyObject *args)

{

    PyObject *typ;

    PyObject *tb = NULL;

    PyObject *val = NULL;

    if (!PyArg_UnpackTuple(args, "throw", 1, 3, &typ, &val, &tb)) {

        return NULL;

    }

    return _gen_throw(gen, 1, typ, val, tb);

}

static PyObject *

gen_iternext(PyGenObject *gen)

{

    return gen_send_ex(gen, NULL, 0, 0);

}

/*

 * Set StopIteration with specified value.  Value can be arbitrary object

 * or NULL.

 *

 * Returns 0 if StopIteration is set and -1 if any other exception is set.

 */

int

_PyGen_SetStopIterationValue(PyObject *value)

{

    PyObject *e;

    if (value == NULL ||

        (!PyTuple_Check(value) && !PyExceptionInstance_Check(value)))

    {

        /* Delay exception instantiation if we can */

        PyErr_SetObject(PyExc_StopIteration, value);

        return 0;

    }

    /* Construct an exception instance manually with

     * PyObject_CallFunctionObjArgs and pass it to PyErr_SetObject.

     *

     * We do this to handle a situation when "value" is a tuple, in which

     * case PyErr_SetObject would set the value of StopIteration to

     * the first element of the tuple.

     *

     * (See PyErr_SetObject/_PyErr_CreateException code for details.)

     */

    e = PyObject_CallFunctionObjArgs(PyExc_StopIteration, value, NULL);

    if (e == NULL) {

        return -1;

    }

    PyErr_SetObject(PyExc_StopIteration, e);

    Py_DECREF(e);

    return 0;

}

/*

 *   If StopIteration exception is set, fetches its 'value'

 *   attribute if any, otherwise sets pvalue to None.

 *

 *   Returns 0 if no exception or StopIteration is set.

 *   If any other exception is set, returns -1 and leaves

 *   pvalue unchanged.

 */

int

_PyGen_FetchStopIterationValue(PyObject **pvalue)

{

    PyObject *et, *ev, *tb;

    PyObject *value = NULL;

    if (PyErr_ExceptionMatches(PyExc_StopIteration)) {

        PyErr_Fetch(&et, &ev, &tb);

        if (ev) {

            /* exception will usually be normalised already */

            if (PyObject_TypeCheck(ev, (PyTypeObject *) et)) {

                value = ((PyStopIterationObject *)ev)->value;

                Py_INCREF(value);

                Py_DECREF(ev);

            } else if (et == PyExc_StopIteration && !PyTuple_Check(ev)) {

                /* Avoid normalisation and take ev as value.

                 *

                 * Normalization is required if the value is a tuple, in

                 * that case the value of StopIteration would be set to

                 * the first element of the tuple.

                 *

                 * (See _PyErr_CreateException code for details.)

                 */

                value = ev;

            } else {

                /* normalisation required */

                PyErr_NormalizeException(&et, &ev, &tb);

                if (!PyObject_TypeCheck(ev, (PyTypeObject *)PyExc_StopIteration)) {

                    PyErr_Restore(et, ev, tb);

                    return -1;

                }

                value = ((PyStopIterationObject *)ev)->value;

                Py_INCREF(value);

                Py_DECREF(ev);

            }

        }

        Py_XDECREF(et);

        Py_XDECREF(tb);

    } else if (PyErr_Occurred()) {

        return -1;

    }

    if (value == NULL) {

        value = Py_None;

        Py_INCREF(value);

    }

    *pvalue = value;

    return 0;

}

static PyObject *

gen_repr(PyGenObject *gen)

{

    return PyUnicode_FromFormat("<generator object %S at %p>",

                                gen->gi_qualname, gen);

}

static PyObject *

gen_get_name(PyGenObject *op)

{

    Py_INCREF(op->gi_name);

    return op->gi_name;

}

static int

gen_set_name(PyGenObject *op, PyObject *value)

{

    /* Not legal to del gen.gi_name or to set it to anything

     * other than a string object. */

    if (value == NULL || !PyUnicode_Check(value)) {

        PyErr_SetString(PyExc_TypeError,

                        "__name__ must be set to a string object");

        return -1;

    }

    Py_INCREF(value);

    Py_XSETREF(op->gi_name, value);

    return 0;

}

static PyObject *

gen_get_qualname(PyGenObject *op)

{

    Py_INCREF(op->gi_qualname);

    return op->gi_qualname;

}

static int

gen_set_qualname(PyGenObject *op, PyObject *value)

{

    /* Not legal to del gen.__qualname__ or to set it to anything

     * other than a string object. */

    if (value == NULL || !PyUnicode_Check(value)) {

        PyErr_SetString(PyExc_TypeError,

                        "__qualname__ must be set to a string object");

        return -1;

    }

    Py_INCREF(value);

    Py_XSETREF(op->gi_qualname, value);

    return 0;

}

static PyObject *

gen_getyieldfrom(PyGenObject *gen)

{

    PyObject *yf = _PyGen_yf(gen);

    if (yf == NULL)

        Py_RETURN_NONE;

    return yf;

}

static PyGetSetDef gen_getsetlist[] = {

    {"__name__", (getter)gen_get_name, (setter)gen_set_name,

     PyDoc_STR("name of the generator")},

    {"__qualname__", (getter)gen_get_qualname, (setter)gen_set_qualname,

     PyDoc_STR("qualified name of the generator")},

    {"gi_yieldfrom", (getter)gen_getyieldfrom, NULL,

     PyDoc_STR("object being iterated by yield from, or None")},

    {NULL} /* Sentinel */

};

static PyMemberDef gen_memberlist[] = {

    {"gi_frame",     T_OBJECT, offsetof(PyGenObject, gi_frame),    READONLY},

    {"gi_running",   T_BOOL,   offsetof(PyGenObject, gi_running),  READONLY},

    {"gi_code",      T_OBJECT, offsetof(PyGenObject, gi_code),     READONLY},

    {NULL}      /* Sentinel */

};

static PyMethodDef gen_methods[] = {

    {"send",(PyCFunction)_PyGen_Send, METH_O, send_doc},

    {"throw",(PyCFunction)gen_throw, METH_VARARGS, throw_doc},

    {"close",(PyCFunction)gen_close, METH_NOARGS, close_doc},

    {NULL, NULL}        /* Sentinel */

};

PyTypeObject PyGen_Type = {

    PyVarObject_HEAD_INIT(&PyType_Type, 0)

    "generator",                                /* tp_name */

    sizeof(PyGenObject),                        /* tp_basicsize */

    0,                                          /* tp_itemsize */

    /* methods */

    (destructor)gen_dealloc,                    /* tp_dealloc */

    0,                                          /* tp_print */

    0,                                          /* tp_getattr */

    0,                                          /* tp_setattr */

    0,                                          /* tp_as_async */

    (reprfunc)gen_repr,                         /* tp_repr */

    0,                                          /* tp_as_number */

    0,                                          /* tp_as_sequence */

    0,                                          /* tp_as_mapping */

    0,                                          /* tp_hash */

    0,                                          /* tp_call */

    0,                                          /* tp_str */

    PyObject_GenericGetAttr,                    /* tp_getattro */

    0,                                          /* tp_setattro */

    0,                                          /* tp_as_buffer */

    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |

        Py_TPFLAGS_HAVE_FINALIZE,               /* tp_flags */

    0,                                          /* tp_doc */

    (traverseproc)gen_traverse,                 /* tp_traverse */

    0,                                          /* tp_clear */

    0,                                          /* tp_richcompare */

    offsetof(PyGenObject, gi_weakreflist),      /* tp_weaklistoffset */

    PyObject_SelfIter,                          /* tp_iter */

    (iternextfunc)gen_iternext,                 /* tp_iternext */

    gen_methods,                                /* tp_methods */

    gen_memberlist,                             /* tp_members */

    gen_getsetlist,                             /* tp_getset */

    0,                                          /* tp_base */

    0,                                          /* tp_dict */

    0,                                          /* tp_descr_get */

    0,                                          /* tp_descr_set */

    0,                                          /* tp_dictoffset */

    0,                                          /* tp_init */

    0,                                          /* tp_alloc */

    0,                                          /* tp_new */

    0,                                          /* tp_free */

    0,                                          /* tp_is_gc */

    0,                                          /* tp_bases */

    0,                                          /* tp_mro */

    0,                                          /* tp_cache */

    0,                                          /* tp_subclasses */

    0,                                          /* tp_weaklist */

    0,                                          /* tp_del */

    0,                                          /* tp_version_tag */

    _PyGen_Finalize,                            /* tp_finalize */

};

static PyObject *

gen_new_with_qualname(PyTypeObject *type, PyFrameObject *f,

                      PyObject *name, PyObject *qualname)

{

    PyGenObject *gen = PyObject_GC_New(PyGenObject, type);

    if (gen == NULL) {

        Py_DECREF(f);

        return NULL;

    }

    gen->gi_frame = f;

    f->f_gen = (PyObject *) gen;

    Py_INCREF(f->f_code);

    gen->gi_code = (PyObject *)(f->f_code);

    gen->gi_running = 0;

    gen->gi_weakreflist = NULL;

    if (name != NULL)

        gen->gi_name = name;

    else

        gen->gi_name = ((PyCodeObject *)gen->gi_code)->co_name;

    Py_INCREF(gen->gi_name);

    if (qualname != NULL)

        gen->gi_qualname = qualname;

    else

        gen->gi_qualname = gen->gi_name;

    Py_INCREF(gen->gi_qualname);

    _PyObject_GC_TRACK(gen);

    return (PyObject *)gen;

}

PyObject *

PyGen_NewWithQualName(PyFrameObject *f, PyObject *name, PyObject *qualname)

{

    return gen_new_with_qualname(&PyGen_Type, f, name, qualname);

}

PyObject *

PyGen_New(PyFrameObject *f)

{

    return gen_new_with_qualname(&PyGen_Type, f, NULL, NULL);

}

int

PyGen_NeedsFinalizing(PyGenObject *gen)

{

    int i;

    PyFrameObject *f = gen->gi_frame;

    if (f == NULL || f->f_stacktop == NULL)

        return 0; /* no frame or empty blockstack == no finalization */

    /* Any block type besides a loop requires cleanup. */

    for (i = 0; i < f->f_iblock; i++)

        if (f->f_blockstack[i].b_type != SETUP_LOOP)

            return 1;

    /* No blocks except loops, it's safe to skip finalization. */

    return 0;

}

/* Coroutine Object */

typedef struct {

    PyObject_HEAD

    PyCoroObject *cw_coroutine;

} PyCoroWrapper;

static int

gen_is_coroutine(PyObject *o)

{

    if (PyGen_CheckExact(o)) {

        PyCodeObject *code = (PyCodeObject *)((PyGenObject*)o)->gi_code;

        if (code->co_flags & CO_ITERABLE_COROUTINE) {

            return 1;

        }

    }

    return 0;

}

/*

 *   This helper function returns an awaitable for `o`:

 *     - `o` if `o` is a coroutine-object;

 *     - `type(o)->tp_as_async->am_await(o)`

 *