/* Generator object implementation */

#define _PY_INTERPRETER

#include "Python.h"

#include "pycore_call.h" // _PyObject_CallNoArgs()

#include "pycore_ceval.h" // _PyEval_EvalFrame()

#include "pycore_frame.h" // _PyInterpreterFrame

#include "pycore_genobject.h" // struct _Py_async_gen_state

#include "pycore_object.h" // _PyObject_GC_UNTRACK()

#include "pycore_opcode.h" // _PyOpcode_Deopt

#include "pycore_pyerrors.h" // _PyErr_ClearExcState()

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

#include "structmember.h" // PyMemberDef

#include "opcode.h" // SEND

#include "pystats.h"

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

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

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

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

"just-started coroutine";

static const char *ASYNC_GEN_IGNORED_EXIT_MSG =

"async generator ignored GeneratorExit";

static inline int

exc_state_traverse(_PyErr_StackItem *exc_state, visitproc visit, void *arg)

{

Py_VISIT(exc_state->exc_value);

return 0;

}

static int

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

{

Py_VISIT(gen->gi_code);

Py_VISIT(gen->gi_name);

Py_VISIT(gen->gi_qualname);

if (gen->gi_frame_state < FRAME_CLEARED) {

_PyInterpreterFrame *frame = (_PyInterpreterFrame *)(gen->gi_iframe);

assert(frame->frame_obj == NULL ||

frame->frame_obj->f_frame->owner == FRAME_OWNED_BY_GENERATOR);

int err = _PyFrame_Traverse(frame, visit, arg);

if (err) {

return err;

}

}

/* No need to visit cr_origin, because it's just tuples/str/int, so can't

participate in a reference cycle. */

return exc_state_traverse(&gen->gi_exc_state, visit, arg);

}

void

_PyGen_Finalize(PyObject *self)

{

PyGenObject *gen = (PyGenObject *)self;

PyObject *res = NULL;

PyObject *error_type, *error_value, *error_traceback;

if (gen->gi_frame_state >= FRAME_COMPLETED) {

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

return;

}

if (PyAsyncGen_CheckExact(self)) {

PyAsyncGenObject *agen = (PyAsyncGenObject*)self;

PyObject *finalizer = agen->ag_origin_or_finalizer;

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

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

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

res = PyObject_CallOneArg(finalizer, self);

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_state == FRAME_CREATED)

{

_PyErr_WarnUnawaitedCoroutine((PyObject *)gen);

}

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

}

if (gen->gi_frame_state < FRAME_CLEARED) {

_PyInterpreterFrame *frame = (_PyInterpreterFrame *)gen->gi_iframe;

gen->gi_frame_state = FRAME_CLEARED;

frame->previous = NULL;

_PyFrame_Clear(frame);

}

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

Py_CLEAR(((PyCoroObject *)gen)->cr_origin_or_finalizer);

}

Py_CLEAR(gen->gi_code);

Py_CLEAR(gen->gi_name);

Py_CLEAR(gen->gi_qualname);

_PyErr_ClearExcState(&gen->gi_exc_state);

PyObject_GC_Del(gen);

}

static PySendResult

gen_send_ex2(PyGenObject *gen, PyObject *arg, PyObject **presult,

int exc, int closing)

{

PyThreadState *tstate = _PyThreadState_GET();

_PyInterpreterFrame *frame = (_PyInterpreterFrame *)gen->gi_iframe;

PyObject *result;

*presult = NULL;

if (gen->gi_frame_state == FRAME_CREATED && arg && arg != Py_None) {

const 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 PYGEN_ERROR;

}

if (gen->gi_frame_state == FRAME_EXECUTING) {

const 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 PYGEN_ERROR;

}

if (gen->gi_frame_state >= FRAME_COMPLETED) {

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 return value if called from send(). */

*presult = Py_None;

Py_INCREF(*presult);

return PYGEN_RETURN;

}

return PYGEN_ERROR;

}

assert(gen->gi_frame_state < FRAME_EXECUTING);

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

result = arg ? arg : Py_None;

Py_INCREF(result);

_PyFrame_StackPush(frame, result);

frame->previous = tstate->cframe->current_frame;

gen->gi_exc_state.previous_item = tstate->exc_info;

tstate->exc_info = &gen->gi_exc_state;

if (exc) {

assert(_PyErr_Occurred(tstate));

_PyErr_ChainStackItem(NULL);

}

gen->gi_frame_state = FRAME_EXECUTING;

EVAL_CALL_STAT_INC(EVAL_CALL_GENERATOR);

result = _PyEval_EvalFrame(tstate, frame, exc);

if (gen->gi_frame_state == FRAME_EXECUTING) {

gen->gi_frame_state = FRAME_COMPLETED;

}

tstate->exc_info = gen->gi_exc_state.previous_item;

gen->gi_exc_state.previous_item = NULL;

assert(tstate->cframe->current_frame == frame->previous);

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

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

* cycle. */

frame->previous = NULL;

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

* that the generator is exhausted. */

if (result) {

if (gen->gi_frame_state == FRAME_SUSPENDED) {

*presult = result;

return PYGEN_NEXT;

}

assert(result == Py_None || !PyAsyncGen_CheckExact(gen));

if (result == Py_None && !PyAsyncGen_CheckExact(gen) && !arg) {

/* Return NULL if called by gen_iternext() */

Py_CLEAR(result);

}

}

else {

if (PyErr_ExceptionMatches(PyExc_StopIteration)) {

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 if (PyAsyncGen_CheckExact(gen) &&

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

}

}

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

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

_PyErr_ClearExcState(&gen->gi_exc_state);

gen->gi_frame_state = FRAME_CLEARED;

_PyFrame_Clear(frame);

*presult = result;

return result ? PYGEN_RETURN : PYGEN_ERROR;

}

static PySendResult

PyGen_am_send(PyGenObject *gen, PyObject *arg, PyObject **result)

{

return gen_send_ex2(gen, arg, result, 0, 0);

}

static PyObject *

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

{

PyObject *result;

if (gen_send_ex2(gen, arg, &result, exc, closing) == PYGEN_RETURN) {

if (PyAsyncGen_CheckExact(gen)) {

assert(result == Py_None);

PyErr_SetNone(PyExc_StopAsyncIteration);

}

else if (result == Py_None) {

PyErr_SetNone(PyExc_StopIteration);

}

else {

_PyGen_SetStopIterationValue(result);

}

Py_CLEAR(result);

}

return result;

}

PyDoc_STRVAR(send_doc,

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

return next yielded value or raise StopIteration.");

static PyObject *

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

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

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

if (retval == NULL)

return -1;

}

else {

PyObject *meth;

if (_PyObject_LookupAttr(yf, &_Py_ID(close), &meth) < 0) {

PyErr_WriteUnraisable(yf);

}

if (meth) {

retval = _PyObject_CallNoArgs(meth);

Py_DECREF(meth);

if (retval == NULL)

return -1;

}

}

Py_XDECREF(retval);

return 0;

}

PyObject *

_PyGen_yf(PyGenObject *gen)

{

PyObject *yf = NULL;

if (gen->gi_frame_state < FRAME_CLEARED) {

_PyInterpreterFrame *frame = (_PyInterpreterFrame *)gen->gi_iframe;

if (gen->gi_frame_state == FRAME_CREATED) {

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

always come after LOAD_CONST: a code object should not start

with SEND */

assert(_Py_OPCODE(_PyCode_CODE(gen->gi_code)[0]) != SEND);

return NULL;

}

_Py_CODEUNIT next = frame->prev_instr[1];

if (_PyOpcode_Deopt[_Py_OPCODE(next)] != RESUME || _Py_OPARG(next) < 2)

{

/* Not in a yield from */

return NULL;

}

yf = _PyFrame_StackPeek(frame);

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

PyFrameState state = gen->gi_frame_state;

gen->gi_frame_state = FRAME_EXECUTING;

err = gen_close_iter(yf);

gen->gi_frame_state = state;

Py_DECREF(yf);

}

if (err == 0)

PyErr_SetNone(PyExc_GeneratorExit);

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

if (retval) {

const 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_RETURN_NONE;

}

return NULL;

}

PyDoc_STRVAR(throw_doc,

"throw(value)\n\

throw(type[,value[,tb]])\n\

\n\

Raise exception in generator, return next yielded value or raise\n\

StopIteration.");

static PyObject *

_gen_throw(PyGenObject *gen, int close_on_genexit,

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

{

PyObject *yf = _PyGen_yf(gen);

if (yf) {

_PyInterpreterFrame *frame = (_PyInterpreterFrame *)gen->gi_iframe;

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.

*/

PyFrameState state = gen->gi_frame_state;

gen->gi_frame_state = FRAME_EXECUTING;

err = gen_close_iter(yf);

gen->gi_frame_state = state;

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

PyThreadState *tstate = _PyThreadState_GET();

/* Since we are fast-tracking things by skipping the eval loop,

we need to update the current frame so the stack trace

will be reported correctly to the user. */

/* XXX We should probably be updating the current frame

somewhere in ceval.c. */

_PyInterpreterFrame *prev = tstate->cframe->current_frame;

frame->previous = prev;

tstate->cframe->current_frame = frame;

/* Close the generator that we are currently iterating with

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

PyFrameState state = gen->gi_frame_state;

gen->gi_frame_state = FRAME_EXECUTING;

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

typ, val, tb);

gen->gi_frame_state = state;

tstate->cframe->current_frame = prev;

frame->previous = NULL;

} else {

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

PyObject *meth;

if (_PyObject_LookupAttr(yf, &_Py_ID(throw), &meth) < 0) {

Py_DECREF(yf);

return NULL;

}

if (meth == NULL) {

Py_DECREF(yf);

goto throw_here;

}

PyFrameState state = gen->gi_frame_state;

gen->gi_frame_state = FRAME_EXECUTING;

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

gen->gi_frame_state = state;

Py_DECREF(meth);

}

Py_DECREF(yf);

if (!ret) {

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 *const *args, Py_ssize_t nargs)

{

PyObject *typ;

PyObject *tb = NULL;

PyObject *val = NULL;

if (!_PyArg_CheckPositional("throw", nargs, 1, 3)) {

return NULL;

}

typ = args[0];

if (nargs == 3) {

val = args[1];

tb = args[2];

}

else if (nargs == 2) {

val = args[1];

}

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

}

static PyObject *

gen_iternext(PyGenObject *gen)

{

PyObject *result;

assert(PyGen_CheckExact(gen) || PyCoro_CheckExact(gen));

if (gen_send_ex2(gen, NULL, &result, 0, 0) == PYGEN_RETURN) {

if (result != Py_None) {

_PyGen_SetStopIterationValue(result);

}

Py_CLEAR(result);

}

return result;

}

/*

* 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_CallOneArg 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_CallOneArg(PyExc_StopIteration, value);

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, void *Py_UNUSED(ignored))

{

Py_INCREF(op->gi_name);

return op->gi_name;

}

static int

gen_set_name(PyGenObject *op, PyObject *value, void *Py_UNUSED(ignored))

{

/* 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, void *Py_UNUSED(ignored))

{

Py_INCREF(op->gi_qualname);

return op->gi_qualname;

}

static int

gen_set_qualname(PyGenObject *op, PyObject *value, void *Py_UNUSED(ignored))

{

/* 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, void *Py_UNUSED(ignored))

{

PyObject *yf = _PyGen_yf(gen);

if (yf == NULL)

Py_RETURN_NONE;

return yf;

}

static PyObject *

gen_getrunning(PyGenObject *gen, void *Py_UNUSED(ignored))

{

if (gen->gi_frame_state == FRAME_EXECUTING) {

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

static PyObject *

gen_getsuspended(PyGenObject *gen, void *Py_UNUSED(ignored))

{

return PyBool_FromLong(gen->gi_frame_state == FRAME_SUSPENDED);

}

static PyObject *

_gen_getframe(PyGenObject *gen, const char *const name)

{

if (PySys_Audit("object.__getattr__", "Os", gen, name) < 0) {

return NULL;

}

if (gen->gi_frame_state == FRAME_CLEARED) {

Py_RETURN_NONE;

}

return _Py_XNewRef((PyObject *)_PyFrame_GetFrameObject((_PyInterpreterFrame *)gen->gi_iframe));

}

static PyObject *

gen_getframe(PyGenObject *gen, void *Py_UNUSED(ignored))

{

return _gen_getframe(gen, "gi_frame");

}

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

{"gi_running", (getter)gen_getrunning, NULL, NULL},

{"gi_frame", (getter)gen_getframe, NULL, NULL},

{"gi_suspended", (getter)gen_getsuspended, NULL, NULL},

{NULL} /* Sentinel */

};

static PyMemberDef gen_memberlist[] = {

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

{NULL} /* Sentinel */

};

static PyObject *

gen_sizeof(PyGenObject *gen, PyObject *Py_UNUSED(ignored))

{

Py_ssize_t res;

res = offsetof(PyGenObject, gi_iframe) + offsetof(_PyInterpreterFrame, localsplus);

PyCodeObject *code = gen->gi_code;

res += (code->co_nlocalsplus+code->co_stacksize) * sizeof(PyObject *);

return PyLong_FromSsize_t(res);

}

PyDoc_STRVAR(sizeof__doc__,

"gen.__sizeof__() -> size of gen in memory, in bytes");

static PyMethodDef gen_methods[] = {

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

{"throw",_PyCFunction_CAST(gen_throw), METH_FASTCALL, throw_doc},

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

{"__sizeof__", (PyCFunction)gen_sizeof, METH_NOARGS, sizeof__doc__},

{NULL, NULL} /* Sentinel */

};

static PyAsyncMethods gen_as_async = {

0, /* am_await */

0, /* am_aiter */

0, /* am_anext */

(sendfunc)PyGen_am_send, /* am_send */

};

PyTypeObject PyGen_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"generator", /* tp_name */

offsetof(PyGenObject, gi_iframe) +

offsetof(_PyInterpreterFrame, localsplus), /* tp_basicsize */

sizeof(PyObject *), /* tp_itemsize */

/* methods */

(destructor)gen_dealloc, /* tp_dealloc */

0, /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

&gen_as_async, /* 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, /* 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 *

make_gen(PyTypeObject *type, PyFunctionObject *func)

{

PyCodeObject *code = (PyCodeObject *)func->func_code;

int slots = code->co_nlocalsplus + code->co_stacksize;

PyGenObject *gen = PyObject_GC_NewVar(PyGenObject, type, slots);

if (gen == NULL) {

return NULL;

}

gen->gi_frame_state = FRAME_CLEARED;

gen->gi_code = (PyCodeObject *)func->func_code;

Py_INCREF(gen->gi_code);

gen->gi_weakreflist = NULL;

gen->gi_exc_state.exc_value = NULL;

gen->gi_exc_state.previous_item = NULL;

assert(func->func_name != NULL);

gen->gi_name = Py_NewRef(func->func_name);

assert(func->func_qualname != NULL);

gen->gi_qualname = Py_NewRef(func->func_qualname);

_PyObject_GC_TRACK(gen);

return (PyObject *)gen;

}

static PyObject *

compute_cr_origin(int origin_depth, _PyInterpreterFrame *current_frame);

PyObject *

_Py_MakeCoro(PyFunctionObject *func)

{

int coro_flags = ((PyCodeObject *)func->func_code)->co_flags &

(CO_GENERATOR | CO_COROUTINE | CO_ASYNC_GENERATOR);

assert(coro_flags);

if (coro_flags == CO_GENERATOR) {

return make_gen(&PyGen_Type, func);

}

if (coro_flags == CO_ASYNC_GENERATOR) {

PyAsyncGenObject *o;

o = (PyAsyncGenObject *)make_gen(&PyAsyncGen_Type, func);

if (o == NULL) {

return NULL;

}

o->ag_origin_or_finalizer = NULL;

o->ag_closed = 0;

o->ag_hooks_inited = 0;

o->ag_running_async = 0;

return (PyObject*)o;

}

assert (coro_flags == CO_COROUTINE);

PyObject *coro = make_gen(&PyCoro_Type, func);

if (!coro) {

return NULL;

}

PyThreadState *tstate = _PyThreadState_GET();

int origin_depth = tstate->coroutine_origin_tracking_depth;

if (origin_depth == 0) {

((PyCoroObject *)coro)->cr_origin_or_finalizer = NULL;

} else {

assert(_PyEval_GetFrame());

PyObject *cr_origin = compute_cr_origin(origin_depth, _PyEval_GetFrame()->previous);

((PyCoroObject *)coro)->cr_origin_or_finalizer = cr_origin;

if (!cr_origin) {

Py_DECREF(coro);

return NULL;

}

}

return coro;

}

static PyObject *

gen_new_with_qualname(PyTypeObject *type, PyFrameObject *f,

PyObject *name, PyObject *qualname)

{

PyCodeObject *code = f->f_frame->f_code;

int size = code->co_nlocalsplus + code->co_stacksize;

PyGenObject *gen = PyObject_GC_NewVar(PyGenObject, type, size);

if (gen == NULL) {

Py_DECREF(f);

return NULL;

}

/* Copy the frame */

assert(f->f_frame->frame_obj == NULL);

assert(f->f_frame->owner == FRAME_OWNED_BY_FRAME_OBJECT);

_PyInterpreterFrame *frame = (_PyInterpreterFrame *)gen->gi_iframe;

_PyFrame_Copy((_PyInterpreterFrame *)f->_f_frame_data, frame);

gen->gi_frame_state = FRAME_CREATED;

assert(frame->frame_obj == f);

f->f_frame = frame;

frame->owner = FRAME_OWNED_BY_GENERATOR;

assert(PyObject_GC_IsTracked((PyObject *)f));

gen->gi_code = PyFrame_GetCode(f);

Py_INCREF(gen->gi_code);

Py_DECREF(f);

gen->gi_weakreflist = NULL;

gen->gi_exc_state.exc_value = NULL;

gen->gi_exc_state.previous_item = NULL;

if (name != NULL)

gen->gi_name = name;

else

gen->gi_name = gen->gi_code->co_name;

Py_INCREF(gen->gi_name);

if (qualname != NULL)

gen->gi_qualname = qualname;

else

gen->gi_qualname = gen->gi_code->co_qualname;

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

}

/* Coroutine Object */