/* 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 "pycore_weakref.h" // FT_CLEAR_WEAKREFS()

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

#ifdef Py_GIL_DISABLED

# define _Py_GEN_TRY_SET_FRAME_STATE(gen, expected, state) \

_Py_atomic_compare_exchange_int8(&(gen)->gi_frame_state, &expected, (state))

#else

# define _Py_GEN_TRY_SET_FRAME_STATE(gen, expected, state) \

((gen)->gi_frame_state = (state), true)

#endif

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)

{

assert(FT_ATOMIC_LOAD_INT8_RELAXED(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);

FT_CLEAR_WEAKREFS(self, gen->gi_weakreflist);

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

}

if (gen->gi_frame_state != FRAME_CLEARED) {

gen->gi_frame_state = FRAME_CLEARED;

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 void

gen_raise_already_executing_error(PyGenObject *gen)

{

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

}

// Send 'arg' into 'gen'. On success, return PYGEN_NEXT or PYGEN_RETURN.

// Returns PYGEN_ERROR on failure. 'presult' is set to the yielded or

// returned value.

// The generator must be in the FRAME_EXECUTING state when this function

// is called.

static PySendResult

gen_send_ex2(PyGenObject *gen, PyObject *arg, PyObject **presult, int exc)

{

assert(FT_ATOMIC_LOAD_INT8_RELAXED(gen->gi_frame_state) == FRAME_EXECUTING);

PyThreadState *tstate = _PyThreadState_GET();

_PyInterpreterFrame *frame = &gen->gi_iframe;

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

}

EVAL_CALL_STAT_INC(EVAL_CALL_GENERATOR);

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

assert(tstate->exc_info == prev_exc_info);

#ifndef Py_GIL_DISABLED

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

assert(frame->previous == NULL);

assert(gen->gi_frame_state != FRAME_EXECUTING);

#endif

// The generator_return_kind field is used to distinguish between a

// yield and a return from within _PyEval_EvalFrame(). Earlier versions

// of CPython (prior to 3.15) used gi_frame_state for this purpose, but

// that requires the GIL for thread-safety.

int return_kind = ((_PyThreadStateImpl *)tstate)->generator_return_kind;

if (return_kind == GENERATOR_YIELD) {

assert(result != NULL && !_PyErr_Occurred(tstate));

*presult = result;

return PYGEN_NEXT;

}

assert(return_kind == GENERATOR_RETURN);

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

assert(FT_ATOMIC_LOAD_INT8_RELAXED(gen->gi_frame_state) == FRAME_CLEARED);

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

* that the generator is exhausted. */

if (result) {

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

}

*presult = result;

return result ? PYGEN_RETURN : PYGEN_ERROR;

}

// Set the generator 'gen' to the executing state and send 'arg' into it.

// See gen_send_ex2() for details.

static PySendResult

gen_send_ex(PyGenObject *gen, PyObject *arg, PyObject **presult)

{

*presult = NULL;

int8_t frame_state = FT_ATOMIC_LOAD_INT8_RELAXED(gen->gi_frame_state);

do {

if (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 (frame_state == FRAME_EXECUTING) {

gen_raise_already_executing_error(gen);

return PYGEN_ERROR;

}

if (FRAME_STATE_FINISHED(frame_state)) {

if (PyCoro_CheckExact(gen)) {

/* `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) {

/* `gen` is an exhausted generator:

only return value if called from send(). */

*presult = Py_None;

return PYGEN_RETURN;

}

return PYGEN_ERROR;

}

assert((frame_state == FRAME_CREATED) ||

FRAME_STATE_SUSPENDED(frame_state));

} while (!_Py_GEN_TRY_SET_FRAME_STATE(gen, frame_state, FRAME_EXECUTING));

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

}

static PySendResult

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

{

PyGenObject *gen = _PyGen_CAST(self);

return gen_send_ex(gen, arg, result);

}

static PyObject *

gen_set_stop_iteration(PyGenObject *gen, PyObject *result)

{

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_DECREF(result);

return NULL;

}

PyDoc_STRVAR(send_doc,

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

return next yielded value or raise StopIteration.");

static PyObject *

gen_send(PyObject *op, PyObject *arg)

{

PyObject *result;

PyGenObject *gen = _PyGen_CAST(op);

if (gen_send_ex(gen, arg, &result) == PYGEN_RETURN) {

return gen_set_stop_iteration(gen, result);

}

return result;

}

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

);

}

static PyObject *

gen_close(PyObject *self, PyObject *args)

{

PyGenObject *gen = _PyGen_CAST(self);

int8_t frame_state = FT_ATOMIC_LOAD_INT8_RELAXED(gen->gi_frame_state);

do {

if (frame_state == FRAME_CREATED) {

if (!_Py_GEN_TRY_SET_FRAME_STATE(gen, frame_state, FRAME_CLEARED)) {

continue;

}

gen_clear_frame(gen);

Py_RETURN_NONE;

}

if (FRAME_STATE_FINISHED(frame_state)) {

Py_RETURN_NONE;

}

if (frame_state == FRAME_EXECUTING) {

gen_raise_already_executing_error(gen);

return NULL;

}

assert(frame_state == FRAME_SUSPENDED_YIELD_FROM ||

frame_state == FRAME_SUSPENDED);

} while (!_Py_GEN_TRY_SET_FRAME_STATE(gen, frame_state, FRAME_EXECUTING));

int err = 0;

_PyInterpreterFrame *frame = &gen->gi_iframe;

if (frame_state == FRAME_SUSPENDED_YIELD_FROM) {

PyObject *yf = PyStackRef_AsPyObjectNew(_PyFrame_StackPeek(frame));

err = gen_close_iter(yf);

Py_DECREF(yf);

}

if (is_resume(frame->instr_ptr)) {

bool no_unwind_tools = _PyEval_NoToolsForUnwind(_PyThreadState_GET());

/* 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 && no_unwind_tools) {

// RESUME after YIELD_VALUE and exception depth is 1

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

FT_ATOMIC_STORE_INT8_RELEASE(gen->gi_frame_state, FRAME_CLEARED);

gen_clear_frame(gen);

Py_RETURN_NONE;

}

}

if (err == 0) {

PyErr_SetNone(PyExc_GeneratorExit);

}

PyObject *retval;

if (gen_send_ex2(gen, Py_None, &retval, 1) == PYGEN_RETURN) {

// the generator returned a value while closing, return the value here

assert(!PyErr_Occurred());

return retval;

}

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

}

return NULL;

}

// Set an exception for a gen.throw() call.

// Return 0 on success, -1 on failure.

static int

gen_set_exception(PyObject *typ, PyObject *val, PyObject *tb)

{

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

}

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

failed_throw:

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

Py_DECREF(typ);

Py_XDECREF(val);

Py_XDECREF(tb);

return -1;

}

static PyObject *

gen_throw_current_exception(PyGenObject *gen)

{

assert(gen->gi_frame_state == FRAME_EXECUTING);

PyObject *result;

if (gen_send_ex2(gen, Py_None, &result, 1) == PYGEN_RETURN) {

return gen_set_stop_iteration(gen, result);

}

return result;

}

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)

{

int8_t frame_state = FT_ATOMIC_LOAD_INT8_RELAXED(gen->gi_frame_state);

do {

if (frame_state == FRAME_EXECUTING) {

gen_raise_already_executing_error(gen);

return NULL;

}

if (FRAME_STATE_FINISHED(frame_state)) {

if (PyCoro_CheckExact(gen)) {

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

PyErr_SetString(

PyExc_RuntimeError,

"cannot reuse already awaited coroutine");

return NULL;

}

gen_set_exception(typ, val, tb);

return NULL;

}

assert((frame_state == FRAME_CREATED) ||

FRAME_STATE_SUSPENDED(frame_state));

} while (!_Py_GEN_TRY_SET_FRAME_STATE(gen, frame_state, FRAME_EXECUTING));

if (frame_state == FRAME_SUSPENDED_YIELD_FROM) {

_PyInterpreterFrame *frame = &gen->gi_iframe;

PyObject *yf = PyStackRef_AsPyObjectNew(_PyFrame_StackPeek(frame));

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.

*/

err = gen_close_iter(yf);

Py_DECREF(yf);

if (err < 0) {

return gen_throw_current_exception(gen);

}

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

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

typ, val, tb);

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

FT_ATOMIC_STORE_INT8_RELEASE(gen->gi_frame_state, frame_state);

return NULL;

}

if (meth == NULL) {

Py_DECREF(yf);

goto throw_here;

}

_PyInterpreterFrame *prev = tstate->current_frame;

frame->previous = prev;

tstate->current_frame = frame;

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

tstate->current_frame = prev;

frame->previous = NULL;

Py_DECREF(meth);

}

Py_DECREF(yf);

if (!ret) {

return gen_throw_current_exception(gen);

}

FT_ATOMIC_STORE_INT8_RELEASE(gen->gi_frame_state, frame_state);

return ret;

}

throw_here:

assert(FT_ATOMIC_LOAD_INT8_RELAXED(gen->gi_frame_state) == FRAME_EXECUTING);

if (gen_set_exception(typ, val, tb) < 0) {

FT_ATOMIC_STORE_INT8_RELEASE(gen->gi_frame_state, frame_state);

return NULL;

}

return gen_throw_current_exception(gen);

}

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_ex(gen, NULL, &result) == 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);

PyObject *name = FT_ATOMIC_LOAD_PTR_ACQUIRE(op->gi_name);

return Py_NewRef(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_BEGIN_CRITICAL_SECTION(self);

// gh-133931: To prevent use-after-free from other threads that reference

// the gi_name.

_PyObject_XSetRefDelayed(&op->gi_name, Py_NewRef(value));

Py_END_CRITICAL_SECTION();

return 0;

}

static PyObject *

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

{

PyGenObject *op = _PyGen_CAST(self);

PyObject *qualname = FT_ATOMIC_LOAD_PTR_ACQUIRE(op->gi_qualname);

return Py_NewRef(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_BEGIN_CRITICAL_SECTION(self);

// gh-133931: To prevent use-after-free from other threads that reference

// the gi_qualname.

_PyObject_XSetRefDelayed(&op->gi_qualname, Py_NewRef(value));

Py_END_CRITICAL_SECTION();

return 0;

}

static PyObject *

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

{

PyGenObject *gen = _PyGen_CAST(self);

int8_t frame_state = FT_ATOMIC_LOAD_INT8_RELAXED(gen->gi_frame_state);

if (frame_state != FRAME_SUSPENDED_YIELD_FROM) {

Py_RETURN_NONE;

}

// TODO: still not thread-safe with free threading

return PyStackRef_AsPyObjectNew(_PyFrame_StackPeek(&gen->gi_iframe));

}

static PyObject *

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

{

PyGenObject *gen = _PyGen_CAST(self);

int8_t frame_state = FT_ATOMIC_LOAD_INT8_RELAXED(gen->gi_frame_state);

return frame_state == FRAME_EXECUTING ? Py_True : Py_False;

}

static PyObject *

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

{

PyGenObject *gen = _PyGen_CAST(self);

int8_t frame_state = FT_ATOMIC_LOAD_INT8_RELAXED(gen->gi_frame_state);

return FRAME_STATE_SUSPENDED(frame_state) ? Py_True : Py_False;

}

static PyObject *

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

{

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

return NULL;

}

int8_t frame_state = FT_ATOMIC_LOAD_INT8_RELAXED(gen->gi_frame_state);

if (FRAME_STATE_FINISHED(frame_state)) {

Py_RETURN_NONE;

}

// TODO: still not thread-safe with free threading

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