#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_lock.h" // _Py_yield()

#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

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

static bool

gen_try_set_frame_state(PyGenObject *gen, int8_t *expected, int8_t state)

{

if (*expected == FRAME_SUSPENDED_YIELD_FROM_LOCKED) {

// Wait for the in-progress gi_yieldfrom read to complete

_Py_yield();

*expected = _Py_atomic_load_int8_relaxed(&gen->gi_frame_state);

return false;

}

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

}

# define _Py_GEN_TRY_SET_FRAME_STATE(gen, expected, state) \

gen_try_set_frame_state((gen), &(expected), (state))

# define _Py_GEN_TRY_SET_FRAME_STATE(gen, expected, state) \

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

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

Py_VISIT(gen->gi_exc_state.exc_value);

return 0;

}

static void

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

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

}

_PyGen_ClearFrame(PyGenObject *gen)

{

int8_t frame_state = FT_ATOMIC_LOAD_INT8_RELAXED(gen->gi_frame_state);

do {

if (FRAME_STATE_FINISHED(frame_state)) {

return 0;

}

else if (frame_state == FRAME_EXECUTING) {

PyErr_SetString(PyExc_RuntimeError,

"cannot clear an executing frame");

return -1;

}

else if (FRAME_STATE_SUSPENDED(frame_state)) {

PyErr_SetString(PyExc_RuntimeError,

"cannot clear an suspended frame");

return -1;

}

assert(frame_state == FRAME_CREATED);

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

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

_PyErr_WarnUnawaitedCoroutine((PyObject *)gen);

}

gen_clear_frame(gen);

return 0;

}

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

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

}

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

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

#ifndef Py_GIL_DISABLED

assert(FRAME_STATE_SUSPENDED(gen->gi_frame_state));

*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

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;

}

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,

PyErr_SetString(

PyExc_RuntimeError,

"cannot reuse already awaited coroutine");

}

else if (arg) {

/* `gen` is an exhausted generator:

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

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

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 == RESUME_CHECK_JIT ||

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

// && (1) to avoid -Wunreachable-code warning on Clang

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

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_SUSPENDED(frame_state));

} 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, 2));

err = gen_close_iter(yf);

Py_DECREF(yf);

}

if (is_resume(frame->instr_ptr)) {

bool no_unwind_tools = _PyEval_NoToolsForUnwind(_PyThreadState_GET(), frame);

/* We can safely ignore the outermost try block

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;

}

static int

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

{

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

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(FT_ATOMIC_LOAD_INT8_RELAXED(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,

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

PyObject *ret;

int err;

if (PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit) &&

close_on_genexit

) {

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

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

_PyInterpreterFrame *prev = tstate->current_frame;

frame->previous = prev;

tstate->current_frame = frame;

/* Close the generator that we are currently iterating with

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;

}

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

}

_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

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

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

#ifdef Py_GIL_DISABLED

int8_t frame_state = _Py_atomic_load_int8_relaxed(&gen->gi_frame_state);

do {

if (frame_state != FRAME_SUSPENDED_YIELD_FROM &&

frame_state != FRAME_SUSPENDED_YIELD_FROM_LOCKED)

{

Py_RETURN_NONE;

}

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

PyObject *result = PyStackRef_AsPyObjectNew(_PyFrame_StackPeek(&gen->gi_iframe, 2));

_Py_atomic_store_int8_release(&gen->gi_frame_state, FRAME_SUSPENDED_YIELD_FROM);

return result;

int8_t frame_state = gen->gi_frame_state;

if (frame_state != FRAME_SUSPENDED_YIELD_FROM) {

Py_RETURN_NONE;

}

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

}

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

{

PyGenObject *gen = _PyGen_CAST(self);

int8_t frame_state = FT_ATOMIC_LOAD_INT8_RELAXED(gen->gi_frame_state);

static PyObject *const state_strings[] = {

[FRAME_CREATED] = &_Py_ID(GEN_CREATED),

[FRAME_SUSPENDED] = &_Py_ID(GEN_SUSPENDED),

[FRAME_SUSPENDED_YIELD_FROM] = &_Py_ID(GEN_SUSPENDED),

[FRAME_SUSPENDED_YIELD_FROM_LOCKED] = &_Py_ID(GEN_SUSPENDED),

[FRAME_EXECUTING] = &_Py_ID(GEN_RUNNING),

[FRAME_CLEARED] = &_Py_ID(GEN_CLOSED),

};

assert(frame_state >= 0 &&

(size_t)frame_state < Py_ARRAY_LENGTH(state_strings));

return state_strings[frame_state];

}

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

{"gi_state", gen_getstate, NULL,

PyDoc_STR("state of the generator")},

{NULL} /* Sentinel */