/* 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_freelist.h" // _Py_FREELIST_FREE()

#include "pycore_gc.h" // _PyGC_CLEAR_FINALIZED()

#include "pycore_genobject.h" // _PyGen_SetStopIterationValue()

#include "pycore_interpframe.h" // _PyFrame_GetCode()

#include "pycore_modsupport.h" // _PyArg_CheckPositional()

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

#include "pycore_opcode_utils.h" // RESUME_AFTER_YIELD_FROM

#include "pycore_pyatomic_ft_wrappers.h" // FT_ATOMIC_LOAD_UINT8_RELAXED()

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

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

#include "pycore_warnings.h" // _PyErr_WarnUnawaitedCoroutine()

#include "opcode_ids.h" // RESUME, etc

// Forward declarations

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

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

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

#define _PyGen_CAST(op) \

_Py_CAST(PyGenObject*, (op))

#define _PyCoroObject_CAST(op) \

(assert(PyCoro_CheckExact(op)), \

_Py_CAST(PyCoroObject*, (op)))

#define _PyAsyncGenObject_CAST(op) \

_Py_CAST(PyAsyncGenObject*, (op))

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

/* Returns a borrowed reference */

static inline PyCodeObject *

_PyGen_GetCode(PyGenObject *gen) {

return _PyFrame_GetCode(&gen->gi_iframe);

}

PyCodeObject *

PyGen_GetCode(PyGenObject *gen) {

assert(PyGen_Check(gen));

PyCodeObject *res = _PyGen_GetCode(gen);

Py_INCREF(res);

return res;

}

static int

gen_traverse(PyObject *self, visitproc visit, void *arg)

{

PyGenObject *gen = _PyGen_CAST(self);

Py_VISIT(gen->gi_name);

Py_VISIT(gen->gi_qualname);

if (gen->gi_frame_state != FRAME_CLEARED) {

_PyInterpreterFrame *frame = &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;

}

}

else {

// We still need to visit the code object when the frame is cleared to

// ensure that it's kept alive if the reference is deferred.

_Py_VISIT_STACKREF(gen->gi_iframe.f_executable);

}

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

participate in a reference cycle. */

Py_VISIT(gen->gi_exc_state.exc_value);

return 0;

}

void

_PyGen_Finalize(PyObject *self)

{

PyGenObject *gen = (PyGenObject *)self;

if (FRAME_STATE_FINISHED(gen->gi_frame_state)) {

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

PyObject *exc = PyErr_GetRaisedException();

PyObject *res = PyObject_CallOneArg(finalizer, self);

if (res == NULL) {

PyErr_FormatUnraisable("Exception ignored while "

"finalizing generator %R", self);

}

else {

Py_DECREF(res);

}

/* Restore the saved exception. */

PyErr_SetRaisedException(exc);

return;

}

}

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

PyObject *exc = PyErr_GetRaisedException();

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

issue a RuntimeWarning. */

assert(_PyGen_GetCode(gen) != NULL);

if (_PyGen_GetCode(gen)->co_flags & CO_COROUTINE &&

gen->gi_frame_state == FRAME_CREATED)

{

_PyErr_WarnUnawaitedCoroutine((PyObject *)gen);

}

else {

PyObject *res = gen_close((PyObject*)gen, NULL);

if (res == NULL) {

if (PyErr_Occurred()) {

PyErr_FormatUnraisable("Exception ignored while "

"closing generator %R", self);

}

}

else {

Py_DECREF(res);

}

}

/* Restore the saved exception. */

PyErr_SetRaisedException(exc);

}

static void

gen_clear_frame(PyGenObject *gen)

{

if (gen->gi_frame_state == FRAME_CLEARED)

return;

gen->gi_frame_state = FRAME_CLEARED;

_PyInterpreterFrame *frame = &gen->gi_iframe;

frame->previous = NULL;

_PyFrame_ClearExceptCode(frame);

_PyErr_ClearExcState(&gen->gi_exc_state);

}

static void

gen_dealloc(PyObject *self)

{

PyGenObject *gen = _PyGen_CAST(self);

_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 (PyCoro_CheckExact(gen)) {

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

}

gen_clear_frame(gen);

assert(gen->gi_exc_state.exc_value == NULL);

PyStackRef_CLEAR(gen->gi_iframe.f_executable);

Py_CLEAR(gen->gi_name);

Py_CLEAR(gen->gi_qualname);

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 = &gen->gi_iframe;

*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 (FRAME_STATE_FINISHED(gen->gi_frame_state)) {

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_NewRef(Py_None);

return PYGEN_RETURN;

}

return PYGEN_ERROR;

}

assert((gen->gi_frame_state == FRAME_CREATED) ||

FRAME_STATE_SUSPENDED(gen->gi_frame_state));

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

PyObject *arg_obj = arg ? arg : Py_None;

_PyFrame_StackPush(frame, PyStackRef_FromPyObjectNew(arg_obj));

_PyErr_StackItem *prev_exc_info = tstate->exc_info;

gen->gi_exc_state.previous_item = prev_exc_info;

tstate->exc_info = &gen->gi_exc_state;

if (exc) {

assert(_PyErr_Occurred(tstate));

_PyErr_ChainStackItem();

}

gen->gi_frame_state = FRAME_EXECUTING;

EVAL_CALL_STAT_INC(EVAL_CALL_GENERATOR);

PyObject *result = _PyEval_EvalFrame(tstate, frame, exc);

assert(tstate->exc_info == prev_exc_info);

assert(gen->gi_exc_state.previous_item == NULL);

assert(gen->gi_frame_state != FRAME_EXECUTING);

assert(frame->previous == NULL);

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

* that the generator is exhausted. */

if (result) {

if (FRAME_STATE_SUSPENDED(gen->gi_frame_state)) {

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

assert(!PyErr_ExceptionMatches(PyExc_StopIteration));

assert(!PyAsyncGen_CheckExact(gen) ||

!PyErr_ExceptionMatches(PyExc_StopAsyncIteration));

}

assert(gen->gi_exc_state.exc_value == NULL);

assert(gen->gi_frame_state == FRAME_CLEARED);

*presult = result;

return result ? PYGEN_RETURN : PYGEN_ERROR;

}

static PySendResult

PyGen_am_send(PyObject *self, PyObject *arg, PyObject **result)

{

PyGenObject *gen = _PyGen_CAST(self);

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(PyObject *gen, PyObject *arg)

{

return gen_send_ex((PyGenObject*)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((PyObject *)yf, NULL);

if (retval == NULL)

return -1;

}

else {

PyObject *meth;

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

PyErr_FormatUnraisable("Exception ignored while "

"closing generator %R", yf);

}

if (meth) {

retval = _PyObject_CallNoArgs(meth);

Py_DECREF(meth);

if (retval == NULL)

return -1;

}

}

Py_XDECREF(retval);

return 0;

}

static inline bool

is_resume(_Py_CODEUNIT *instr)

{

uint8_t code = FT_ATOMIC_LOAD_UINT8_RELAXED(instr->op.code);

return (

code == RESUME ||

code == RESUME_CHECK ||

code == INSTRUMENTED_RESUME

);

}

PyObject *

_PyGen_yf(PyGenObject *gen)

{

if (gen->gi_frame_state == FRAME_SUSPENDED_YIELD_FROM) {

_PyInterpreterFrame *frame = &gen->gi_iframe;

// GH-122390: These asserts are wrong in the presence of ENTER_EXECUTOR!

// assert(is_resume(frame->instr_ptr));

// assert((frame->instr_ptr->op.arg & RESUME_OPARG_LOCATION_MASK) >= RESUME_AFTER_YIELD_FROM);

return PyStackRef_AsPyObjectNew(_PyFrame_StackPeek(frame));

}

return NULL;

}

static PyObject *

gen_close(PyObject *self, PyObject *args)

{

PyGenObject *gen = _PyGen_CAST(self);

if (gen->gi_frame_state == FRAME_CREATED) {

gen->gi_frame_state = FRAME_COMPLETED;

Py_RETURN_NONE;

}

if (FRAME_STATE_FINISHED(gen->gi_frame_state)) {

Py_RETURN_NONE;

}

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

}

_PyInterpreterFrame *frame = &gen->gi_iframe;

if (is_resume(frame->instr_ptr)) {

/* We can safely ignore the outermost try block

* as it is automatically generated to handle

* StopIteration. */

int oparg = frame->instr_ptr->op.arg;

if (oparg & RESUME_OPARG_DEPTH1_MASK) {

// RESUME after YIELD_VALUE and exception depth is 1

assert((oparg & RESUME_OPARG_LOCATION_MASK) != RESUME_AT_FUNC_START);

gen->gi_frame_state = FRAME_COMPLETED;

gen_clear_frame(gen);

Py_RETURN_NONE;

}

}

if (err == 0) {

PyErr_SetNone(PyExc_GeneratorExit);

}

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

}

assert(PyErr_Occurred());

if (PyErr_ExceptionMatches(PyExc_GeneratorExit)) {

PyErr_Clear(); /* ignore this error */

Py_RETURN_NONE;

}

/* if the generator returned a value while closing, StopIteration was

* raised in gen_send_ex() above; retrieve and return the value here */

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

return retval;

}

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.\n\

the (type, val, tb) signature is deprecated, \n\

and may be removed in a future version of Python.");

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 = &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;

}

PyThreadState *tstate = _PyThreadState_GET();

assert(tstate != NULL);

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

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

/* Link frame into the stack to enable complete backtraces. */

/* XXX We should probably be updating the current frame somewhere in

ceval.c. */

_PyInterpreterFrame *prev = tstate->current_frame;

frame->previous = prev;

tstate->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->current_frame = prev;

frame->previous = NULL;

} else {

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

PyObject *meth;

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

Py_DECREF(yf);

return NULL;

}

if (meth == NULL) {

Py_DECREF(yf);

goto throw_here;

}

_PyInterpreterFrame *prev = tstate->current_frame;

frame->previous = prev;

tstate->current_frame = frame;

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;

tstate->current_frame = prev;

frame->previous = NULL;

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_XSETREF(val, typ);

typ = Py_NewRef(PyExceptionInstance_Class(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(PyObject *op, PyObject *const *args, Py_ssize_t nargs)

{

PyGenObject *gen = _PyGen_CAST(op);

PyObject *typ;

PyObject *tb = NULL;

PyObject *val = NULL;

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

return NULL;

}

if (nargs > 1) {

if (PyErr_WarnEx(PyExc_DeprecationWarning,

"the (type, exc, tb) signature of throw() is deprecated, "

"use the single-arg signature instead.",

1) < 0) {

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(PyObject *self)

{

assert(PyGen_CheckExact(self) || PyCoro_CheckExact(self));

PyGenObject *gen = _PyGen_CAST(self);

PyObject *result;

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)

{

assert(!PyErr_Occurred());

// Construct an exception instance manually with PyObject_CallOneArg()

// but use PyErr_SetRaisedException() instead of PyErr_SetObject() as

// PyErr_SetObject(exc_type, value) has a fast path when 'value'

// is a tuple, where the value of the StopIteration exception would be

// set to 'value[0]' instead of 'value'.

PyObject *exc = value == NULL

? PyObject_CallNoArgs(PyExc_StopIteration)

: PyObject_CallOneArg(PyExc_StopIteration, value);

if (exc == NULL) {

return -1;

}

PyErr_SetRaisedException(exc /* stolen */);

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 *value = NULL;

if (PyErr_ExceptionMatches(PyExc_StopIteration)) {

PyObject *exc = PyErr_GetRaisedException();

value = Py_NewRef(((PyStopIterationObject *)exc)->value);

Py_DECREF(exc);

} else if (PyErr_Occurred()) {

return -1;

}

if (value == NULL) {

value = Py_NewRef(Py_None);

}

*pvalue = value;

return 0;

}

static PyObject *

gen_repr(PyObject *self)

{

PyGenObject *gen = _PyGen_CAST(self);

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

gen->gi_qualname, gen);

}

static PyObject *

gen_get_name(PyObject *self, void *Py_UNUSED(ignored))

{

PyGenObject *op = _PyGen_CAST(self);

return Py_NewRef(op->gi_name);

}

static int

gen_set_name(PyObject *self, PyObject *value, void *Py_UNUSED(ignored))

{

PyGenObject *op = _PyGen_CAST(self);

/* 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_XSETREF(op->gi_name, Py_NewRef(value));

return 0;

}

static PyObject *

gen_get_qualname(PyObject *self, void *Py_UNUSED(ignored))

{

PyGenObject *op = _PyGen_CAST(self);

return Py_NewRef(op->gi_qualname);

}

static int

gen_set_qualname(PyObject *self, PyObject *value, void *Py_UNUSED(ignored))

{

PyGenObject *op = _PyGen_CAST(self);

/* 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_XSETREF(op->gi_qualname, Py_NewRef(value));

return 0;

}

static PyObject *

gen_getyieldfrom(PyObject *gen, void *Py_UNUSED(ignored))

{

PyObject *yf = _PyGen_yf(_PyGen_CAST(gen));

if (yf == NULL) {

Py_RETURN_NONE;

}

return yf;

}

static PyObject *

gen_getrunning(PyObject *self, void *Py_UNUSED(ignored))

{

PyGenObject *gen = _PyGen_CAST(self);

if (gen->gi_frame_state == FRAME_EXECUTING) {

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

static PyObject *

gen_getsuspended(PyObject *self, void *Py_UNUSED(ignored))

{

PyGenObject *gen = _PyGen_CAST(self);

return PyBool_FromLong(FRAME_STATE_SUSPENDED(gen->gi_frame_state));

}

static PyObject *

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

{

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

return NULL;

}

if (FRAME_STATE_FINISHED(gen->gi_frame_state)) {

Py_RETURN_NONE;

}

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

}

static PyObject *

gen_getframe(PyObject *self, void *Py_UNUSED(ignored))

{

PyGenObject *gen = _PyGen_CAST(self);

return _gen_getframe(gen, "gi_frame");

}

static PyObject *

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

{

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

return NULL;

}

return Py_NewRef(_PyGen_GetCode(gen));

}

static PyObject *

gen_getcode(PyObject *self, void *Py_UNUSED(ignored))

{

PyGenObject *gen = _PyGen_CAST(self);

return _gen_getcode(gen, "gi_code");

}

static PyGetSetDef gen_getsetlist[] = {

{"__name__", gen_get_name, gen_set_name,

PyDoc_STR("name of the generator")},

{"__qualname__", gen_get_qualname, gen_set_qualname,

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

{"gi_yieldfrom", gen_getyieldfrom, NULL,

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

{"gi_running", gen_getrunning, NULL, NULL},

{"gi_frame", gen_getframe, NULL, NULL},

{"gi_suspended", gen_getsuspended, NULL, NULL},

{"gi_code", gen_getcode, NULL, NULL},

{NULL} /* Sentinel */

};

static PyMemberDef gen_memberlist[] = {

{NULL} /* Sentinel */

};

static PyObject *

gen_sizeof(PyObject *op, PyObject *Py_UNUSED(ignored))

{

PyGenObject *gen = _PyGen_CAST(op);

Py_ssize_t res;

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

PyCodeObject *code = _PyGen_GetCode(gen);

res += _PyFrame_NumSlotsForCodeObject(code) * 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", gen_send, METH_O, send_doc},

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

{"close", gen_close, METH_NOARGS, close_doc},

{"__sizeof__", gen_sizeof, METH_NOARGS, sizeof__doc__},

{"__class_getitem__", Py_GenericAlias, METH_O|METH_CLASS, PyDoc_STR("See PEP 585")},

{NULL, NULL} /* Sentinel */

};

static PyAsyncMethods gen_as_async = {

0, /* am_await */

0, /* am_aiter */

0, /* am_anext */

PyGen_am_send, /* am_send */

};

PyTypeObject PyGen_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"generator", /* tp_name */

offsetof(PyGenObject, gi_iframe.localsplus), /* tp_basicsize */

sizeof(PyObject *), /* tp_itemsize */

/* methods */

gen_dealloc, /* tp_dealloc */

0, /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

&gen_as_async, /* tp_as_async */

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

gen_traverse, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

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

PyObject_SelfIter, /* tp_iter */

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 = _PyFrame_NumSlotsForCodeObject(code);

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

if (gen == NULL) {

return NULL;

}

gen->gi_frame_state = FRAME_CLEARED;

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

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

if (ag == NULL) {

return NULL;

}

ag->ag_origin_or_finalizer = NULL;

ag->ag_closed = 0;

ag->ag_hooks_inited = 0;

ag->ag_running_async = 0;

return (PyObject*)ag;

}

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 {

_PyInterpreterFrame *frame = tstate->current_frame;

assert(frame);

assert(_PyFrame_IsIncomplete(frame));

frame = _PyFrame_GetFirstComplete(frame->previous);

PyObject *cr_origin = compute_cr_origin(origin_depth, frame);

((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 = _PyFrame_GetCode(f->f_frame);

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 = &gen->gi_iframe;

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

gen->gi_frame_state = FRAME_CREATED;

assert(frame->frame_obj == f);