1 /* Generator object implementation */
2
3 #include "Python.h"
4 #include "internal/pystate.h"
5 #include "frameobject.h"
6 #include "structmember.h"
7 #include "opcode.h"
8
9 static PyObject *gen_close(PyGenObject *, PyObject *);
10 static PyObject *async_gen_asend_new(PyAsyncGenObject *, PyObject *);
11 static PyObject *async_gen_athrow_new(PyAsyncGenObject *, PyObject *);
12
13 static char *NON_INIT_CORO_MSG = "can't send non-None value to a "
14 "just-started coroutine";
15
16 static char *ASYNC_GEN_IGNORED_EXIT_MSG =
17 "async generator ignored GeneratorExit";
18
19 static inline int
exc_state_traverse(_PyErr_StackItem * exc_state,visitproc visit,void * arg)20 exc_state_traverse(_PyErr_StackItem *exc_state, visitproc visit, void *arg)
21 {
22 Py_VISIT(exc_state->exc_type);
23 Py_VISIT(exc_state->exc_value);
24 Py_VISIT(exc_state->exc_traceback);
25 return 0;
26 }
27
28 static int
gen_traverse(PyGenObject * gen,visitproc visit,void * arg)29 gen_traverse(PyGenObject *gen, visitproc visit, void *arg)
30 {
31 Py_VISIT((PyObject *)gen->gi_frame);
32 Py_VISIT(gen->gi_code);
33 Py_VISIT(gen->gi_name);
34 Py_VISIT(gen->gi_qualname);
35 /* No need to visit cr_origin, because it's just tuples/str/int, so can't
36 participate in a reference cycle. */
37 return exc_state_traverse(&gen->gi_exc_state, visit, arg);
38 }
39
40 void
_PyGen_Finalize(PyObject * self)41 _PyGen_Finalize(PyObject *self)
42 {
43 PyGenObject *gen = (PyGenObject *)self;
44 PyObject *res = NULL;
45 PyObject *error_type, *error_value, *error_traceback;
46
47 if (gen->gi_frame == NULL || gen->gi_frame->f_stacktop == NULL) {
48 /* Generator isn't paused, so no need to close */
49 return;
50 }
51
52 if (PyAsyncGen_CheckExact(self)) {
53 PyAsyncGenObject *agen = (PyAsyncGenObject*)self;
54 PyObject *finalizer = agen->ag_finalizer;
55 if (finalizer && !agen->ag_closed) {
56 /* Save the current exception, if any. */
57 PyErr_Fetch(&error_type, &error_value, &error_traceback);
58
59 res = PyObject_CallFunctionObjArgs(finalizer, self, NULL);
60
61 if (res == NULL) {
62 PyErr_WriteUnraisable(self);
63 } else {
64 Py_DECREF(res);
65 }
66 /* Restore the saved exception. */
67 PyErr_Restore(error_type, error_value, error_traceback);
68 return;
69 }
70 }
71
72 /* Save the current exception, if any. */
73 PyErr_Fetch(&error_type, &error_value, &error_traceback);
74
75 /* If `gen` is a coroutine, and if it was never awaited on,
76 issue a RuntimeWarning. */
77 if (gen->gi_code != NULL &&
78 ((PyCodeObject *)gen->gi_code)->co_flags & CO_COROUTINE &&
79 gen->gi_frame->f_lasti == -1)
80 {
81 _PyErr_WarnUnawaitedCoroutine((PyObject *)gen);
82 }
83 else {
84 res = gen_close(gen, NULL);
85 }
86
87 if (res == NULL) {
88 if (PyErr_Occurred()) {
89 PyErr_WriteUnraisable(self);
90 }
91 }
92 else {
93 Py_DECREF(res);
94 }
95
96 /* Restore the saved exception. */
97 PyErr_Restore(error_type, error_value, error_traceback);
98 }
99
100 static inline void
exc_state_clear(_PyErr_StackItem * exc_state)101 exc_state_clear(_PyErr_StackItem *exc_state)
102 {
103 PyObject *t, *v, *tb;
104 t = exc_state->exc_type;
105 v = exc_state->exc_value;
106 tb = exc_state->exc_traceback;
107 exc_state->exc_type = NULL;
108 exc_state->exc_value = NULL;
109 exc_state->exc_traceback = NULL;
110 Py_XDECREF(t);
111 Py_XDECREF(v);
112 Py_XDECREF(tb);
113 }
114
115 static void
gen_dealloc(PyGenObject * gen)116 gen_dealloc(PyGenObject *gen)
117 {
118 PyObject *self = (PyObject *) gen;
119
120 _PyObject_GC_UNTRACK(gen);
121
122 if (gen->gi_weakreflist != NULL)
123 PyObject_ClearWeakRefs(self);
124
125 _PyObject_GC_TRACK(self);
126
127 if (PyObject_CallFinalizerFromDealloc(self))
128 return; /* resurrected. :( */
129
130 _PyObject_GC_UNTRACK(self);
131 if (PyAsyncGen_CheckExact(gen)) {
132 /* We have to handle this case for asynchronous generators
133 right here, because this code has to be between UNTRACK
134 and GC_Del. */
135 Py_CLEAR(((PyAsyncGenObject*)gen)->ag_finalizer);
136 }
137 if (gen->gi_frame != NULL) {
138 gen->gi_frame->f_gen = NULL;
139 Py_CLEAR(gen->gi_frame);
140 }
141 if (((PyCodeObject *)gen->gi_code)->co_flags & CO_COROUTINE) {
142 Py_CLEAR(((PyCoroObject *)gen)->cr_origin);
143 }
144 Py_CLEAR(gen->gi_code);
145 Py_CLEAR(gen->gi_name);
146 Py_CLEAR(gen->gi_qualname);
147 exc_state_clear(&gen->gi_exc_state);
148 PyObject_GC_Del(gen);
149 }
150
151 static PyObject *
gen_send_ex(PyGenObject * gen,PyObject * arg,int exc,int closing)152 gen_send_ex(PyGenObject *gen, PyObject *arg, int exc, int closing)
153 {
154 PyThreadState *tstate = PyThreadState_GET();
155 PyFrameObject *f = gen->gi_frame;
156 PyObject *result;
157
158 if (gen->gi_running) {
159 const char *msg = "generator already executing";
160 if (PyCoro_CheckExact(gen)) {
161 msg = "coroutine already executing";
162 }
163 else if (PyAsyncGen_CheckExact(gen)) {
164 msg = "async generator already executing";
165 }
166 PyErr_SetString(PyExc_ValueError, msg);
167 return NULL;
168 }
169 if (f == NULL || f->f_stacktop == NULL) {
170 if (PyCoro_CheckExact(gen) && !closing) {
171 /* `gen` is an exhausted coroutine: raise an error,
172 except when called from gen_close(), which should
173 always be a silent method. */
174 PyErr_SetString(
175 PyExc_RuntimeError,
176 "cannot reuse already awaited coroutine");
177 }
178 else if (arg && !exc) {
179 /* `gen` is an exhausted generator:
180 only set exception if called from send(). */
181 if (PyAsyncGen_CheckExact(gen)) {
182 PyErr_SetNone(PyExc_StopAsyncIteration);
183 }
184 else {
185 PyErr_SetNone(PyExc_StopIteration);
186 }
187 }
188 return NULL;
189 }
190
191 if (f->f_lasti == -1) {
192 if (arg && arg != Py_None) {
193 const char *msg = "can't send non-None value to a "
194 "just-started generator";
195 if (PyCoro_CheckExact(gen)) {
196 msg = NON_INIT_CORO_MSG;
197 }
198 else if (PyAsyncGen_CheckExact(gen)) {
199 msg = "can't send non-None value to a "
200 "just-started async generator";
201 }
202 PyErr_SetString(PyExc_TypeError, msg);
203 return NULL;
204 }
205 } else {
206 /* Push arg onto the frame's value stack */
207 result = arg ? arg : Py_None;
208 Py_INCREF(result);
209 *(f->f_stacktop++) = result;
210 }
211
212 /* Generators always return to their most recent caller, not
213 * necessarily their creator. */
214 Py_XINCREF(tstate->frame);
215 assert(f->f_back == NULL);
216 f->f_back = tstate->frame;
217
218 gen->gi_running = 1;
219 gen->gi_exc_state.previous_item = tstate->exc_info;
220 tstate->exc_info = &gen->gi_exc_state;
221 result = PyEval_EvalFrameEx(f, exc);
222 tstate->exc_info = gen->gi_exc_state.previous_item;
223 gen->gi_exc_state.previous_item = NULL;
224 gen->gi_running = 0;
225
226 /* Don't keep the reference to f_back any longer than necessary. It
227 * may keep a chain of frames alive or it could create a reference
228 * cycle. */
229 assert(f->f_back == tstate->frame);
230 Py_CLEAR(f->f_back);
231
232 /* If the generator just returned (as opposed to yielding), signal
233 * that the generator is exhausted. */
234 if (result && f->f_stacktop == NULL) {
235 if (result == Py_None) {
236 /* Delay exception instantiation if we can */
237 if (PyAsyncGen_CheckExact(gen)) {
238 PyErr_SetNone(PyExc_StopAsyncIteration);
239 }
240 else {
241 PyErr_SetNone(PyExc_StopIteration);
242 }
243 }
244 else {
245 /* Async generators cannot return anything but None */
246 assert(!PyAsyncGen_CheckExact(gen));
247 _PyGen_SetStopIterationValue(result);
248 }
249 Py_CLEAR(result);
250 }
251 else if (!result && PyErr_ExceptionMatches(PyExc_StopIteration)) {
252 const char *msg = "generator raised StopIteration";
253 if (PyCoro_CheckExact(gen)) {
254 msg = "coroutine raised StopIteration";
255 }
256 else if PyAsyncGen_CheckExact(gen) {
257 msg = "async generator raised StopIteration";
258 }
259 _PyErr_FormatFromCause(PyExc_RuntimeError, "%s", msg);
260
261 }
262 else if (!result && PyAsyncGen_CheckExact(gen) &&
263 PyErr_ExceptionMatches(PyExc_StopAsyncIteration))
264 {
265 /* code in `gen` raised a StopAsyncIteration error:
266 raise a RuntimeError.
267 */
268 const char *msg = "async generator raised StopAsyncIteration";
269 _PyErr_FormatFromCause(PyExc_RuntimeError, "%s", msg);
270 }
271
272 if (!result || f->f_stacktop == NULL) {
273 /* generator can't be rerun, so release the frame */
274 /* first clean reference cycle through stored exception traceback */
275 exc_state_clear(&gen->gi_exc_state);
276 gen->gi_frame->f_gen = NULL;
277 gen->gi_frame = NULL;
278 Py_DECREF(f);
279 }
280
281 return result;
282 }
283
284 PyDoc_STRVAR(send_doc,
285 "send(arg) -> send 'arg' into generator,\n\
286 return next yielded value or raise StopIteration.");
287
288 PyObject *
_PyGen_Send(PyGenObject * gen,PyObject * arg)289 _PyGen_Send(PyGenObject *gen, PyObject *arg)
290 {
291 return gen_send_ex(gen, arg, 0, 0);
292 }
293
294 PyDoc_STRVAR(close_doc,
295 "close() -> raise GeneratorExit inside generator.");
296
297 /*
298 * This helper function is used by gen_close and gen_throw to
299 * close a subiterator being delegated to by yield-from.
300 */
301
302 static int
gen_close_iter(PyObject * yf)303 gen_close_iter(PyObject *yf)
304 {
305 PyObject *retval = NULL;
306 _Py_IDENTIFIER(close);
307
308 if (PyGen_CheckExact(yf) || PyCoro_CheckExact(yf)) {
309 retval = gen_close((PyGenObject *)yf, NULL);
310 if (retval == NULL)
311 return -1;
312 }
313 else {
314 PyObject *meth;
315 if (_PyObject_LookupAttrId(yf, &PyId_close, &meth) < 0) {
316 PyErr_WriteUnraisable(yf);
317 }
318 if (meth) {
319 retval = _PyObject_CallNoArg(meth);
320 Py_DECREF(meth);
321 if (retval == NULL)
322 return -1;
323 }
324 }
325 Py_XDECREF(retval);
326 return 0;
327 }
328
329 PyObject *
_PyGen_yf(PyGenObject * gen)330 _PyGen_yf(PyGenObject *gen)
331 {
332 PyObject *yf = NULL;
333 PyFrameObject *f = gen->gi_frame;
334
335 if (f && f->f_stacktop) {
336 PyObject *bytecode = f->f_code->co_code;
337 unsigned char *code = (unsigned char *)PyBytes_AS_STRING(bytecode);
338
339 if (f->f_lasti < 0) {
340 /* Return immediately if the frame didn't start yet. YIELD_FROM
341 always come after LOAD_CONST: a code object should not start
342 with YIELD_FROM */
343 assert(code[0] != YIELD_FROM);
344 return NULL;
345 }
346
347 if (code[f->f_lasti + sizeof(_Py_CODEUNIT)] != YIELD_FROM)
348 return NULL;
349 yf = f->f_stacktop[-1];
350 Py_INCREF(yf);
351 }
352
353 return yf;
354 }
355
356 static PyObject *
gen_close(PyGenObject * gen,PyObject * args)357 gen_close(PyGenObject *gen, PyObject *args)
358 {
359 PyObject *retval;
360 PyObject *yf = _PyGen_yf(gen);
361 int err = 0;
362
363 if (yf) {
364 gen->gi_running = 1;
365 err = gen_close_iter(yf);
366 gen->gi_running = 0;
367 Py_DECREF(yf);
368 }
369 if (err == 0)
370 PyErr_SetNone(PyExc_GeneratorExit);
371 retval = gen_send_ex(gen, Py_None, 1, 1);
372 if (retval) {
373 const char *msg = "generator ignored GeneratorExit";
374 if (PyCoro_CheckExact(gen)) {
375 msg = "coroutine ignored GeneratorExit";
376 } else if (PyAsyncGen_CheckExact(gen)) {
377 msg = ASYNC_GEN_IGNORED_EXIT_MSG;
378 }
379 Py_DECREF(retval);
380 PyErr_SetString(PyExc_RuntimeError, msg);
381 return NULL;
382 }
383 if (PyErr_ExceptionMatches(PyExc_StopIteration)
384 || PyErr_ExceptionMatches(PyExc_GeneratorExit)) {
385 PyErr_Clear(); /* ignore these errors */
386 Py_RETURN_NONE;
387 }
388 return NULL;
389 }
390
391
392 PyDoc_STRVAR(throw_doc,
393 "throw(typ[,val[,tb]]) -> raise exception in generator,\n\
394 return next yielded value or raise StopIteration.");
395
396 static PyObject *
_gen_throw(PyGenObject * gen,int close_on_genexit,PyObject * typ,PyObject * val,PyObject * tb)397 _gen_throw(PyGenObject *gen, int close_on_genexit,
398 PyObject *typ, PyObject *val, PyObject *tb)
399 {
400 PyObject *yf = _PyGen_yf(gen);
401 _Py_IDENTIFIER(throw);
402
403 if (yf) {
404 PyObject *ret;
405 int err;
406 if (PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit) &&
407 close_on_genexit
408 ) {
409 /* Asynchronous generators *should not* be closed right away.
410 We have to allow some awaits to work it through, hence the
411 `close_on_genexit` parameter here.
412 */
413 gen->gi_running = 1;
414 err = gen_close_iter(yf);
415 gen->gi_running = 0;
416 Py_DECREF(yf);
417 if (err < 0)
418 return gen_send_ex(gen, Py_None, 1, 0);
419 goto throw_here;
420 }
421 if (PyGen_CheckExact(yf) || PyCoro_CheckExact(yf)) {
422 /* `yf` is a generator or a coroutine. */
423 gen->gi_running = 1;
424 /* Close the generator that we are currently iterating with
425 'yield from' or awaiting on with 'await'. */
426 ret = _gen_throw((PyGenObject *)yf, close_on_genexit,
427 typ, val, tb);
428 gen->gi_running = 0;
429 } else {
430 /* `yf` is an iterator or a coroutine-like object. */
431 PyObject *meth;
432 if (_PyObject_LookupAttrId(yf, &PyId_throw, &meth) < 0) {
433 Py_DECREF(yf);
434 return NULL;
435 }
436 if (meth == NULL) {
437 Py_DECREF(yf);
438 goto throw_here;
439 }
440 gen->gi_running = 1;
441 ret = PyObject_CallFunctionObjArgs(meth, typ, val, tb, NULL);
442 gen->gi_running = 0;
443 Py_DECREF(meth);
444 }
445 Py_DECREF(yf);
446 if (!ret) {
447 PyObject *val;
448 /* Pop subiterator from stack */
449 ret = *(--gen->gi_frame->f_stacktop);
450 assert(ret == yf);
451 Py_DECREF(ret);
452 /* Termination repetition of YIELD_FROM */
453 assert(gen->gi_frame->f_lasti >= 0);
454 gen->gi_frame->f_lasti += sizeof(_Py_CODEUNIT);
455 if (_PyGen_FetchStopIterationValue(&val) == 0) {
456 ret = gen_send_ex(gen, val, 0, 0);
457 Py_DECREF(val);
458 } else {
459 ret = gen_send_ex(gen, Py_None, 1, 0);
460 }
461 }
462 return ret;
463 }
464
465 throw_here:
466 /* First, check the traceback argument, replacing None with
467 NULL. */
468 if (tb == Py_None) {
469 tb = NULL;
470 }
471 else if (tb != NULL && !PyTraceBack_Check(tb)) {
472 PyErr_SetString(PyExc_TypeError,
473 "throw() third argument must be a traceback object");
474 return NULL;
475 }
476
477 Py_INCREF(typ);
478 Py_XINCREF(val);
479 Py_XINCREF(tb);
480
481 if (PyExceptionClass_Check(typ))
482 PyErr_NormalizeException(&typ, &val, &tb);
483
484 else if (PyExceptionInstance_Check(typ)) {
485 /* Raising an instance. The value should be a dummy. */
486 if (val && val != Py_None) {
487 PyErr_SetString(PyExc_TypeError,
488 "instance exception may not have a separate value");
489 goto failed_throw;
490 }
491 else {
492 /* Normalize to raise <class>, <instance> */
493 Py_XDECREF(val);
494 val = typ;
495 typ = PyExceptionInstance_Class(typ);
496 Py_INCREF(typ);
497
498 if (tb == NULL)
499 /* Returns NULL if there's no traceback */
500 tb = PyException_GetTraceback(val);
501 }
502 }
503 else {
504 /* Not something you can raise. throw() fails. */
505 PyErr_Format(PyExc_TypeError,
506 "exceptions must be classes or instances "
507 "deriving from BaseException, not %s",
508 Py_TYPE(typ)->tp_name);
509 goto failed_throw;
510 }
511
512 PyErr_Restore(typ, val, tb);
513 return gen_send_ex(gen, Py_None, 1, 0);
514
515 failed_throw:
516 /* Didn't use our arguments, so restore their original refcounts */
517 Py_DECREF(typ);
518 Py_XDECREF(val);
519 Py_XDECREF(tb);
520 return NULL;
521 }
522
523
524 static PyObject *
gen_throw(PyGenObject * gen,PyObject * args)525 gen_throw(PyGenObject *gen, PyObject *args)
526 {
527 PyObject *typ;
528 PyObject *tb = NULL;
529 PyObject *val = NULL;
530
531 if (!PyArg_UnpackTuple(args, "throw", 1, 3, &typ, &val, &tb)) {
532 return NULL;
533 }
534
535 return _gen_throw(gen, 1, typ, val, tb);
536 }
537
538
539 static PyObject *
gen_iternext(PyGenObject * gen)540 gen_iternext(PyGenObject *gen)
541 {
542 return gen_send_ex(gen, NULL, 0, 0);
543 }
544
545 /*
546 * Set StopIteration with specified value. Value can be arbitrary object
547 * or NULL.
548 *
549 * Returns 0 if StopIteration is set and -1 if any other exception is set.
550 */
551 int
_PyGen_SetStopIterationValue(PyObject * value)552 _PyGen_SetStopIterationValue(PyObject *value)
553 {
554 PyObject *e;
555
556 if (value == NULL ||
557 (!PyTuple_Check(value) && !PyExceptionInstance_Check(value)))
558 {
559 /* Delay exception instantiation if we can */
560 PyErr_SetObject(PyExc_StopIteration, value);
561 return 0;
562 }
563 /* Construct an exception instance manually with
564 * PyObject_CallFunctionObjArgs and pass it to PyErr_SetObject.
565 *
566 * We do this to handle a situation when "value" is a tuple, in which
567 * case PyErr_SetObject would set the value of StopIteration to
568 * the first element of the tuple.
569 *
570 * (See PyErr_SetObject/_PyErr_CreateException code for details.)
571 */
572 e = PyObject_CallFunctionObjArgs(PyExc_StopIteration, value, NULL);
573 if (e == NULL) {
574 return -1;
575 }
576 PyErr_SetObject(PyExc_StopIteration, e);
577 Py_DECREF(e);
578 return 0;
579 }
580
581 /*
582 * If StopIteration exception is set, fetches its 'value'
583 * attribute if any, otherwise sets pvalue to None.
584 *
585 * Returns 0 if no exception or StopIteration is set.
586 * If any other exception is set, returns -1 and leaves
587 * pvalue unchanged.
588 */
589
590 int
_PyGen_FetchStopIterationValue(PyObject ** pvalue)591 _PyGen_FetchStopIterationValue(PyObject **pvalue)
592 {
593 PyObject *et, *ev, *tb;
594 PyObject *value = NULL;
595
596 if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
597 PyErr_Fetch(&et, &ev, &tb);
598 if (ev) {
599 /* exception will usually be normalised already */
600 if (PyObject_TypeCheck(ev, (PyTypeObject *) et)) {
601 value = ((PyStopIterationObject *)ev)->value;
602 Py_INCREF(value);
603 Py_DECREF(ev);
604 } else if (et == PyExc_StopIteration && !PyTuple_Check(ev)) {
605 /* Avoid normalisation and take ev as value.
606 *
607 * Normalization is required if the value is a tuple, in
608 * that case the value of StopIteration would be set to
609 * the first element of the tuple.
610 *
611 * (See _PyErr_CreateException code for details.)
612 */
613 value = ev;
614 } else {
615 /* normalisation required */
616 PyErr_NormalizeException(&et, &ev, &tb);
617 if (!PyObject_TypeCheck(ev, (PyTypeObject *)PyExc_StopIteration)) {
618 PyErr_Restore(et, ev, tb);
619 return -1;
620 }
621 value = ((PyStopIterationObject *)ev)->value;
622 Py_INCREF(value);
623 Py_DECREF(ev);
624 }
625 }
626 Py_XDECREF(et);
627 Py_XDECREF(tb);
628 } else if (PyErr_Occurred()) {
629 return -1;
630 }
631 if (value == NULL) {
632 value = Py_None;
633 Py_INCREF(value);
634 }
635 *pvalue = value;
636 return 0;
637 }
638
639 static PyObject *
gen_repr(PyGenObject * gen)640 gen_repr(PyGenObject *gen)
641 {
642 return PyUnicode_FromFormat("<generator object %S at %p>",
643 gen->gi_qualname, gen);
644 }
645
646 static PyObject *
gen_get_name(PyGenObject * op,void * Py_UNUSED (ignored))647 gen_get_name(PyGenObject *op, void *Py_UNUSED(ignored))
648 {
649 Py_INCREF(op->gi_name);
650 return op->gi_name;
651 }
652
653 static int
gen_set_name(PyGenObject * op,PyObject * value,void * Py_UNUSED (ignored))654 gen_set_name(PyGenObject *op, PyObject *value, void *Py_UNUSED(ignored))
655 {
656 /* Not legal to del gen.gi_name or to set it to anything
657 * other than a string object. */
658 if (value == NULL || !PyUnicode_Check(value)) {
659 PyErr_SetString(PyExc_TypeError,
660 "__name__ must be set to a string object");
661 return -1;
662 }
663 Py_INCREF(value);
664 Py_XSETREF(op->gi_name, value);
665 return 0;
666 }
667
668 static PyObject *
gen_get_qualname(PyGenObject * op,void * Py_UNUSED (ignored))669 gen_get_qualname(PyGenObject *op, void *Py_UNUSED(ignored))
670 {
671 Py_INCREF(op->gi_qualname);
672 return op->gi_qualname;
673 }
674
675 static int
gen_set_qualname(PyGenObject * op,PyObject * value,void * Py_UNUSED (ignored))676 gen_set_qualname(PyGenObject *op, PyObject *value, void *Py_UNUSED(ignored))
677 {
678 /* Not legal to del gen.__qualname__ or to set it to anything
679 * other than a string object. */
680 if (value == NULL || !PyUnicode_Check(value)) {
681 PyErr_SetString(PyExc_TypeError,
682 "__qualname__ must be set to a string object");
683 return -1;
684 }
685 Py_INCREF(value);
686 Py_XSETREF(op->gi_qualname, value);
687 return 0;
688 }
689
690 static PyObject *
gen_getyieldfrom(PyGenObject * gen,void * Py_UNUSED (ignored))691 gen_getyieldfrom(PyGenObject *gen, void *Py_UNUSED(ignored))
692 {
693 PyObject *yf = _PyGen_yf(gen);
694 if (yf == NULL)
695 Py_RETURN_NONE;
696 return yf;
697 }
698
699 static PyGetSetDef gen_getsetlist[] = {
700 {"__name__", (getter)gen_get_name, (setter)gen_set_name,
701 PyDoc_STR("name of the generator")},
702 {"__qualname__", (getter)gen_get_qualname, (setter)gen_set_qualname,
703 PyDoc_STR("qualified name of the generator")},
704 {"gi_yieldfrom", (getter)gen_getyieldfrom, NULL,
705 PyDoc_STR("object being iterated by yield from, or None")},
706 {NULL} /* Sentinel */
707 };
708
709 static PyMemberDef gen_memberlist[] = {
710 {"gi_frame", T_OBJECT, offsetof(PyGenObject, gi_frame), READONLY},
711 {"gi_running", T_BOOL, offsetof(PyGenObject, gi_running), READONLY},
712 {"gi_code", T_OBJECT, offsetof(PyGenObject, gi_code), READONLY},
713 {NULL} /* Sentinel */
714 };
715
716 static PyMethodDef gen_methods[] = {
717 {"send",(PyCFunction)_PyGen_Send, METH_O, send_doc},
718 {"throw",(PyCFunction)gen_throw, METH_VARARGS, throw_doc},
719 {"close",(PyCFunction)gen_close, METH_NOARGS, close_doc},
720 {NULL, NULL} /* Sentinel */
721 };
722
723 PyTypeObject PyGen_Type = {
724 PyVarObject_HEAD_INIT(&PyType_Type, 0)
725 "generator", /* tp_name */
726 sizeof(PyGenObject), /* tp_basicsize */
727 0, /* tp_itemsize */
728 /* methods */
729 (destructor)gen_dealloc, /* tp_dealloc */
730 0, /* tp_print */
731 0, /* tp_getattr */
732 0, /* tp_setattr */
733 0, /* tp_as_async */
734 (reprfunc)gen_repr, /* tp_repr */
735 0, /* tp_as_number */
736 0, /* tp_as_sequence */
737 0, /* tp_as_mapping */
738 0, /* tp_hash */
739 0, /* tp_call */
740 0, /* tp_str */
741 PyObject_GenericGetAttr, /* tp_getattro */
742 0, /* tp_setattro */
743 0, /* tp_as_buffer */
744 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
745 Py_TPFLAGS_HAVE_FINALIZE, /* tp_flags */
746 0, /* tp_doc */
747 (traverseproc)gen_traverse, /* tp_traverse */
748 0, /* tp_clear */
749 0, /* tp_richcompare */
750 offsetof(PyGenObject, gi_weakreflist), /* tp_weaklistoffset */
751 PyObject_SelfIter, /* tp_iter */
752 (iternextfunc)gen_iternext, /* tp_iternext */
753 gen_methods, /* tp_methods */
754 gen_memberlist, /* tp_members */
755 gen_getsetlist, /* tp_getset */
756 0, /* tp_base */
757 0, /* tp_dict */
758
759 0, /* tp_descr_get */
760 0, /* tp_descr_set */
761 0, /* tp_dictoffset */
762 0, /* tp_init */
763 0, /* tp_alloc */
764 0, /* tp_new */
765 0, /* tp_free */
766 0, /* tp_is_gc */
767 0, /* tp_bases */
768 0, /* tp_mro */
769 0, /* tp_cache */
770 0, /* tp_subclasses */
771 0, /* tp_weaklist */
772 0, /* tp_del */
773 0, /* tp_version_tag */
774 _PyGen_Finalize, /* tp_finalize */
775 };
776
777 static PyObject *
gen_new_with_qualname(PyTypeObject * type,PyFrameObject * f,PyObject * name,PyObject * qualname)778 gen_new_with_qualname(PyTypeObject *type, PyFrameObject *f,
779 PyObject *name, PyObject *qualname)
780 {
781 PyGenObject *gen = PyObject_GC_New(PyGenObject, type);
782 if (gen == NULL) {
783 Py_DECREF(f);
784 return NULL;
785 }
786 gen->gi_frame = f;
787 f->f_gen = (PyObject *) gen;
788 Py_INCREF(f->f_code);
789 gen->gi_code = (PyObject *)(f->f_code);
790 gen->gi_running = 0;
791 gen->gi_weakreflist = NULL;
792 gen->gi_exc_state.exc_type = NULL;
793 gen->gi_exc_state.exc_value = NULL;
794 gen->gi_exc_state.exc_traceback = NULL;
795 gen->gi_exc_state.previous_item = NULL;
796 if (name != NULL)
797 gen->gi_name = name;
798 else
799 gen->gi_name = ((PyCodeObject *)gen->gi_code)->co_name;
800 Py_INCREF(gen->gi_name);
801 if (qualname != NULL)
802 gen->gi_qualname = qualname;
803 else
804 gen->gi_qualname = gen->gi_name;
805 Py_INCREF(gen->gi_qualname);
806 _PyObject_GC_TRACK(gen);
807 return (PyObject *)gen;
808 }
809
810 PyObject *
PyGen_NewWithQualName(PyFrameObject * f,PyObject * name,PyObject * qualname)811 PyGen_NewWithQualName(PyFrameObject *f, PyObject *name, PyObject *qualname)
812 {
813 return gen_new_with_qualname(&PyGen_Type, f, name, qualname);
814 }
815
816 PyObject *
PyGen_New(PyFrameObject * f)817 PyGen_New(PyFrameObject *f)
818 {
819 return gen_new_with_qualname(&PyGen_Type, f, NULL, NULL);
820 }
821
822 int
PyGen_NeedsFinalizing(PyGenObject * gen)823 PyGen_NeedsFinalizing(PyGenObject *gen)
824 {
825 int i;
826 PyFrameObject *f = gen->gi_frame;
827
828 if (f == NULL || f->f_stacktop == NULL)
829 return 0; /* no frame or empty blockstack == no finalization */
830
831 /* Any block type besides a loop requires cleanup. */
832 for (i = 0; i < f->f_iblock; i++)
833 if (f->f_blockstack[i].b_type != SETUP_LOOP)
834 return 1;
835
836 /* No blocks except loops, it's safe to skip finalization. */
837 return 0;
838 }
839
840 /* Coroutine Object */
841
842 typedef struct {
843 PyObject_HEAD
844 PyCoroObject *cw_coroutine;
845 } PyCoroWrapper;
846
847 static int
gen_is_coroutine(PyObject * o)848 gen_is_coroutine(PyObject *o)
849 {
850 if (PyGen_CheckExact(o)) {
851 PyCodeObject *code = (PyCodeObject *)((PyGenObject*)o)->gi_code;
852 if (code->co_flags & CO_ITERABLE_COROUTINE) {
853 return 1;
854 }
855 }
856 return 0;
857 }
858
859 /*
860 * This helper function returns an awaitable for `o`:
861 * - `o` if `o` is a coroutine-object;
862 * - `type(o)->tp_as_async->am_await(o)`
863 *
864 * Raises a TypeError if it's not possible to return
865 * an awaitable and returns NULL.
866 */
867 PyObject *
_PyCoro_GetAwaitableIter(PyObject * o)868 _PyCoro_GetAwaitableIter(PyObject *o)
869 {
870 unaryfunc getter = NULL;
871 PyTypeObject *ot;
872
873 if (PyCoro_CheckExact(o) || gen_is_coroutine(o)) {
874 /* 'o' is a coroutine. */
875 Py_INCREF(o);
876 return o;
877 }
878
879 ot = Py_TYPE(o);
880 if (ot->tp_as_async != NULL) {
881 getter = ot->tp_as_async->am_await;
882 }
883 if (getter != NULL) {
884 PyObject *res = (*getter)(o);
885 if (res != NULL) {
886 if (PyCoro_CheckExact(res) || gen_is_coroutine(res)) {
887 /* __await__ must return an *iterator*, not
888 a coroutine or another awaitable (see PEP 492) */
889 PyErr_SetString(PyExc_TypeError,
890 "__await__() returned a coroutine");
891 Py_CLEAR(res);
892 } else if (!PyIter_Check(res)) {
893 PyErr_Format(PyExc_TypeError,
894 "__await__() returned non-iterator "
895 "of type '%.100s'",
896 Py_TYPE(res)->tp_name);
897 Py_CLEAR(res);
898 }
899 }
900 return res;
901 }
902
903 PyErr_Format(PyExc_TypeError,
904 "object %.100s can't be used in 'await' expression",
905 ot->tp_name);
906 return NULL;
907 }
908
909 static PyObject *
coro_repr(PyCoroObject * coro)910 coro_repr(PyCoroObject *coro)
911 {
912 return PyUnicode_FromFormat("<coroutine object %S at %p>",
913 coro->cr_qualname, coro);
914 }
915
916 static PyObject *
coro_await(PyCoroObject * coro)917 coro_await(PyCoroObject *coro)
918 {
919 PyCoroWrapper *cw = PyObject_GC_New(PyCoroWrapper, &_PyCoroWrapper_Type);
920 if (cw == NULL) {
921 return NULL;
922 }
923 Py_INCREF(coro);
924 cw->cw_coroutine = coro;
925 _PyObject_GC_TRACK(cw);
926 return (PyObject *)cw;
927 }
928
929 static PyObject *
coro_get_cr_await(PyCoroObject * coro,void * Py_UNUSED (ignored))930 coro_get_cr_await(PyCoroObject *coro, void *Py_UNUSED(ignored))
931 {
932 PyObject *yf = _PyGen_yf((PyGenObject *) coro);
933 if (yf == NULL)
934 Py_RETURN_NONE;
935 return yf;
936 }
937
938 static PyGetSetDef coro_getsetlist[] = {
939 {"__name__", (getter)gen_get_name, (setter)gen_set_name,
940 PyDoc_STR("name of the coroutine")},
941 {"__qualname__", (getter)gen_get_qualname, (setter)gen_set_qualname,
942 PyDoc_STR("qualified name of the coroutine")},
943 {"cr_await", (getter)coro_get_cr_await, NULL,
944 PyDoc_STR("object being awaited on, or None")},
945 {NULL} /* Sentinel */
946 };
947
948 static PyMemberDef coro_memberlist[] = {
949 {"cr_frame", T_OBJECT, offsetof(PyCoroObject, cr_frame), READONLY},
950 {"cr_running", T_BOOL, offsetof(PyCoroObject, cr_running), READONLY},
951 {"cr_code", T_OBJECT, offsetof(PyCoroObject, cr_code), READONLY},
952 {"cr_origin", T_OBJECT, offsetof(PyCoroObject, cr_origin), READONLY},
953 {NULL} /* Sentinel */
954 };
955
956 PyDoc_STRVAR(coro_send_doc,
957 "send(arg) -> send 'arg' into coroutine,\n\
958 return next iterated value or raise StopIteration.");
959
960 PyDoc_STRVAR(coro_throw_doc,
961 "throw(typ[,val[,tb]]) -> raise exception in coroutine,\n\
962 return next iterated value or raise StopIteration.");
963
964 PyDoc_STRVAR(coro_close_doc,
965 "close() -> raise GeneratorExit inside coroutine.");
966
967 static PyMethodDef coro_methods[] = {
968 {"send",(PyCFunction)_PyGen_Send, METH_O, coro_send_doc},
969 {"throw",(PyCFunction)gen_throw, METH_VARARGS, coro_throw_doc},
970 {"close",(PyCFunction)gen_close, METH_NOARGS, coro_close_doc},
971 {NULL, NULL} /* Sentinel */
972 };
973
974 static PyAsyncMethods coro_as_async = {
975 (unaryfunc)coro_await, /* am_await */
976 0, /* am_aiter */
977 0 /* am_anext */
978 };
979
980 PyTypeObject PyCoro_Type = {
981 PyVarObject_HEAD_INIT(&PyType_Type, 0)
982 "coroutine", /* tp_name */
983 sizeof(PyCoroObject), /* tp_basicsize */
984 0, /* tp_itemsize */
985 /* methods */
986 (destructor)gen_dealloc, /* tp_dealloc */
987 0, /* tp_print */
988 0, /* tp_getattr */
989 0, /* tp_setattr */
990 &coro_as_async, /* tp_as_async */
991 (reprfunc)coro_repr, /* tp_repr */
992 0, /* tp_as_number */
993 0, /* tp_as_sequence */
994 0, /* tp_as_mapping */
995 0, /* tp_hash */
996 0, /* tp_call */
997 0, /* tp_str */
998 PyObject_GenericGetAttr, /* tp_getattro */
999 0, /* tp_setattro */
1000 0, /* tp_as_buffer */
1001 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
1002 Py_TPFLAGS_HAVE_FINALIZE, /* tp_flags */
1003 0, /* tp_doc */
1004 (traverseproc)gen_traverse, /* tp_traverse */
1005 0, /* tp_clear */
1006 0, /* tp_richcompare */
1007 offsetof(PyCoroObject, cr_weakreflist), /* tp_weaklistoffset */
1008 0, /* tp_iter */
1009 0, /* tp_iternext */
1010 coro_methods, /* tp_methods */
1011 coro_memberlist, /* tp_members */
1012 coro_getsetlist, /* tp_getset */
1013 0, /* tp_base */
1014 0, /* tp_dict */
1015 0, /* tp_descr_get */
1016 0, /* tp_descr_set */
1017 0, /* tp_dictoffset */
1018 0, /* tp_init */
1019 0, /* tp_alloc */
1020 0, /* tp_new */
1021 0, /* tp_free */
1022 0, /* tp_is_gc */
1023 0, /* tp_bases */
1024 0, /* tp_mro */
1025 0, /* tp_cache */
1026 0, /* tp_subclasses */
1027 0, /* tp_weaklist */
1028 0, /* tp_del */
1029 0, /* tp_version_tag */
1030 _PyGen_Finalize, /* tp_finalize */
1031 };
1032
1033 static void
coro_wrapper_dealloc(PyCoroWrapper * cw)1034 coro_wrapper_dealloc(PyCoroWrapper *cw)
1035 {
1036 _PyObject_GC_UNTRACK((PyObject *)cw);
1037 Py_CLEAR(cw->cw_coroutine);
1038 PyObject_GC_Del(cw);
1039 }
1040
1041 static PyObject *
coro_wrapper_iternext(PyCoroWrapper * cw)1042 coro_wrapper_iternext(PyCoroWrapper *cw)
1043 {
1044 return gen_send_ex((PyGenObject *)cw->cw_coroutine, NULL, 0, 0);
1045 }
1046
1047 static PyObject *
coro_wrapper_send(PyCoroWrapper * cw,PyObject * arg)1048 coro_wrapper_send(PyCoroWrapper *cw, PyObject *arg)
1049 {
1050 return gen_send_ex((PyGenObject *)cw->cw_coroutine, arg, 0, 0);
1051 }
1052
1053 static PyObject *
coro_wrapper_throw(PyCoroWrapper * cw,PyObject * args)1054 coro_wrapper_throw(PyCoroWrapper *cw, PyObject *args)
1055 {
1056 return gen_throw((PyGenObject *)cw->cw_coroutine, args);
1057 }
1058
1059 static PyObject *
coro_wrapper_close(PyCoroWrapper * cw,PyObject * args)1060 coro_wrapper_close(PyCoroWrapper *cw, PyObject *args)
1061 {
1062 return gen_close((PyGenObject *)cw->cw_coroutine, args);
1063 }
1064
1065 static int
coro_wrapper_traverse(PyCoroWrapper * cw,visitproc visit,void * arg)1066 coro_wrapper_traverse(PyCoroWrapper *cw, visitproc visit, void *arg)
1067 {
1068 Py_VISIT((PyObject *)cw->cw_coroutine);
1069 return 0;
1070 }
1071
1072 static PyMethodDef coro_wrapper_methods[] = {
1073 {"send",(PyCFunction)coro_wrapper_send, METH_O, coro_send_doc},
1074 {"throw",(PyCFunction)coro_wrapper_throw, METH_VARARGS, coro_throw_doc},
1075 {"close",(PyCFunction)coro_wrapper_close, METH_NOARGS, coro_close_doc},
1076 {NULL, NULL} /* Sentinel */
1077 };
1078
1079 PyTypeObject _PyCoroWrapper_Type = {
1080 PyVarObject_HEAD_INIT(&PyType_Type, 0)
1081 "coroutine_wrapper",
1082 sizeof(PyCoroWrapper), /* tp_basicsize */
1083 0, /* tp_itemsize */
1084 (destructor)coro_wrapper_dealloc, /* destructor tp_dealloc */
1085 0, /* tp_print */
1086 0, /* tp_getattr */
1087 0, /* tp_setattr */
1088 0, /* tp_as_async */
1089 0, /* tp_repr */
1090 0, /* tp_as_number */
1091 0, /* tp_as_sequence */
1092 0, /* tp_as_mapping */
1093 0, /* tp_hash */
1094 0, /* tp_call */
1095 0, /* tp_str */
1096 PyObject_GenericGetAttr, /* tp_getattro */
1097 0, /* tp_setattro */
1098 0, /* tp_as_buffer */
1099 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
1100 "A wrapper object implementing __await__ for coroutines.",
1101 (traverseproc)coro_wrapper_traverse, /* tp_traverse */
1102 0, /* tp_clear */
1103 0, /* tp_richcompare */
1104 0, /* tp_weaklistoffset */
1105 PyObject_SelfIter, /* tp_iter */
1106 (iternextfunc)coro_wrapper_iternext, /* tp_iternext */
1107 coro_wrapper_methods, /* tp_methods */
1108 0, /* tp_members */
1109 0, /* tp_getset */
1110 0, /* tp_base */
1111 0, /* tp_dict */
1112 0, /* tp_descr_get */
1113 0, /* tp_descr_set */
1114 0, /* tp_dictoffset */
1115 0, /* tp_init */
1116 0, /* tp_alloc */
1117 0, /* tp_new */
1118 0, /* tp_free */
1119 };
1120
1121 static PyObject *
compute_cr_origin(int origin_depth)1122 compute_cr_origin(int origin_depth)
1123 {
1124 PyFrameObject *frame = PyEval_GetFrame();
1125 /* First count how many frames we have */
1126 int frame_count = 0;
1127 for (; frame && frame_count < origin_depth; ++frame_count) {
1128 frame = frame->f_back;
1129 }
1130
1131 /* Now collect them */
1132 PyObject *cr_origin = PyTuple_New(frame_count);
1133 if (cr_origin == NULL) {
1134 return NULL;
1135 }
1136 frame = PyEval_GetFrame();
1137 for (int i = 0; i < frame_count; ++i) {
1138 PyObject *frameinfo = Py_BuildValue(
1139 "OiO",
1140 frame->f_code->co_filename,
1141 PyFrame_GetLineNumber(frame),
1142 frame->f_code->co_name);
1143 if (!frameinfo) {
1144 Py_DECREF(cr_origin);
1145 return NULL;
1146 }
1147 PyTuple_SET_ITEM(cr_origin, i, frameinfo);
1148 frame = frame->f_back;
1149 }
1150
1151 return cr_origin;
1152 }
1153
1154 PyObject *
PyCoro_New(PyFrameObject * f,PyObject * name,PyObject * qualname)1155 PyCoro_New(PyFrameObject *f, PyObject *name, PyObject *qualname)
1156 {
1157 PyObject *coro = gen_new_with_qualname(&PyCoro_Type, f, name, qualname);
1158 if (!coro) {
1159 return NULL;
1160 }
1161
1162 PyThreadState *tstate = PyThreadState_GET();
1163 int origin_depth = tstate->coroutine_origin_tracking_depth;
1164
1165 if (origin_depth == 0) {
1166 ((PyCoroObject *)coro)->cr_origin = NULL;
1167 } else {
1168 PyObject *cr_origin = compute_cr_origin(origin_depth);
1169 ((PyCoroObject *)coro)->cr_origin = cr_origin;
1170 if (!cr_origin) {
1171 Py_DECREF(coro);
1172 return NULL;
1173 }
1174 }
1175
1176 return coro;
1177 }
1178
1179
1180 /* ========= Asynchronous Generators ========= */
1181
1182
1183 typedef enum {
1184 AWAITABLE_STATE_INIT, /* new awaitable, has not yet been iterated */
1185 AWAITABLE_STATE_ITER, /* being iterated */
1186 AWAITABLE_STATE_CLOSED, /* closed */
1187 } AwaitableState;
1188
1189
1190 typedef struct {
1191 PyObject_HEAD
1192 PyAsyncGenObject *ags_gen;
1193
1194 /* Can be NULL, when in the __anext__() mode
1195 (equivalent of "asend(None)") */
1196 PyObject *ags_sendval;
1197
1198 AwaitableState ags_state;
1199 } PyAsyncGenASend;
1200
1201
1202 typedef struct {
1203 PyObject_HEAD
1204 PyAsyncGenObject *agt_gen;
1205
1206 /* Can be NULL, when in the "aclose()" mode
1207 (equivalent of "athrow(GeneratorExit)") */
1208 PyObject *agt_args;
1209
1210 AwaitableState agt_state;
1211 } PyAsyncGenAThrow;
1212
1213
1214 typedef struct {
1215 PyObject_HEAD
1216 PyObject *agw_val;
1217 } _PyAsyncGenWrappedValue;
1218
1219
1220 #ifndef _PyAsyncGen_MAXFREELIST
1221 #define _PyAsyncGen_MAXFREELIST 80
1222 #endif
1223
1224 /* Freelists boost performance 6-10%; they also reduce memory
1225 fragmentation, as _PyAsyncGenWrappedValue and PyAsyncGenASend
1226 are short-living objects that are instantiated for every
1227 __anext__ call.
1228 */
1229
1230 static _PyAsyncGenWrappedValue *ag_value_freelist[_PyAsyncGen_MAXFREELIST];
1231 static int ag_value_freelist_free = 0;
1232
1233 static PyAsyncGenASend *ag_asend_freelist[_PyAsyncGen_MAXFREELIST];
1234 static int ag_asend_freelist_free = 0;
1235
1236 #define _PyAsyncGenWrappedValue_CheckExact(o) \
1237 (Py_TYPE(o) == &_PyAsyncGenWrappedValue_Type)
1238
1239 #define PyAsyncGenASend_CheckExact(o) \
1240 (Py_TYPE(o) == &_PyAsyncGenASend_Type)
1241
1242
1243 static int
async_gen_traverse(PyAsyncGenObject * gen,visitproc visit,void * arg)1244 async_gen_traverse(PyAsyncGenObject *gen, visitproc visit, void *arg)
1245 {
1246 Py_VISIT(gen->ag_finalizer);
1247 return gen_traverse((PyGenObject*)gen, visit, arg);
1248 }
1249
1250
1251 static PyObject *
async_gen_repr(PyAsyncGenObject * o)1252 async_gen_repr(PyAsyncGenObject *o)
1253 {
1254 return PyUnicode_FromFormat("<async_generator object %S at %p>",
1255 o->ag_qualname, o);
1256 }
1257
1258
1259 static int
async_gen_init_hooks(PyAsyncGenObject * o)1260 async_gen_init_hooks(PyAsyncGenObject *o)
1261 {
1262 PyThreadState *tstate;
1263 PyObject *finalizer;
1264 PyObject *firstiter;
1265
1266 if (o->ag_hooks_inited) {
1267 return 0;
1268 }
1269
1270 o->ag_hooks_inited = 1;
1271
1272 tstate = PyThreadState_GET();
1273
1274 finalizer = tstate->async_gen_finalizer;
1275 if (finalizer) {
1276 Py_INCREF(finalizer);
1277 o->ag_finalizer = finalizer;
1278 }
1279
1280 firstiter = tstate->async_gen_firstiter;
1281 if (firstiter) {
1282 PyObject *res;
1283
1284 Py_INCREF(firstiter);
1285 res = PyObject_CallFunctionObjArgs(firstiter, o, NULL);
1286 Py_DECREF(firstiter);
1287 if (res == NULL) {
1288 return 1;
1289 }
1290 Py_DECREF(res);
1291 }
1292
1293 return 0;
1294 }
1295
1296
1297 static PyObject *
async_gen_anext(PyAsyncGenObject * o)1298 async_gen_anext(PyAsyncGenObject *o)
1299 {
1300 if (async_gen_init_hooks(o)) {
1301 return NULL;
1302 }
1303 return async_gen_asend_new(o, NULL);
1304 }
1305
1306
1307 static PyObject *
async_gen_asend(PyAsyncGenObject * o,PyObject * arg)1308 async_gen_asend(PyAsyncGenObject *o, PyObject *arg)
1309 {
1310 if (async_gen_init_hooks(o)) {
1311 return NULL;
1312 }
1313 return async_gen_asend_new(o, arg);
1314 }
1315
1316
1317 static PyObject *
async_gen_aclose(PyAsyncGenObject * o,PyObject * arg)1318 async_gen_aclose(PyAsyncGenObject *o, PyObject *arg)
1319 {
1320 if (async_gen_init_hooks(o)) {
1321 return NULL;
1322 }
1323 return async_gen_athrow_new(o, NULL);
1324 }
1325
1326 static PyObject *
async_gen_athrow(PyAsyncGenObject * o,PyObject * args)1327 async_gen_athrow(PyAsyncGenObject *o, PyObject *args)
1328 {
1329 if (async_gen_init_hooks(o)) {
1330 return NULL;
1331 }
1332 return async_gen_athrow_new(o, args);
1333 }
1334
1335
1336 static PyGetSetDef async_gen_getsetlist[] = {
1337 {"__name__", (getter)gen_get_name, (setter)gen_set_name,
1338 PyDoc_STR("name of the async generator")},
1339 {"__qualname__", (getter)gen_get_qualname, (setter)gen_set_qualname,
1340 PyDoc_STR("qualified name of the async generator")},
1341 {"ag_await", (getter)coro_get_cr_await, NULL,
1342 PyDoc_STR("object being awaited on, or None")},
1343 {NULL} /* Sentinel */
1344 };
1345
1346 static PyMemberDef async_gen_memberlist[] = {
1347 {"ag_frame", T_OBJECT, offsetof(PyAsyncGenObject, ag_frame), READONLY},
1348 {"ag_running", T_BOOL, offsetof(PyAsyncGenObject, ag_running), READONLY},
1349 {"ag_code", T_OBJECT, offsetof(PyAsyncGenObject, ag_code), READONLY},
1350 {NULL} /* Sentinel */
1351 };
1352
1353 PyDoc_STRVAR(async_aclose_doc,
1354 "aclose() -> raise GeneratorExit inside generator.");
1355
1356 PyDoc_STRVAR(async_asend_doc,
1357 "asend(v) -> send 'v' in generator.");
1358
1359 PyDoc_STRVAR(async_athrow_doc,
1360 "athrow(typ[,val[,tb]]) -> raise exception in generator.");
1361
1362 static PyMethodDef async_gen_methods[] = {
1363 {"asend", (PyCFunction)async_gen_asend, METH_O, async_asend_doc},
1364 {"athrow",(PyCFunction)async_gen_athrow, METH_VARARGS, async_athrow_doc},
1365 {"aclose", (PyCFunction)async_gen_aclose, METH_NOARGS, async_aclose_doc},
1366 {NULL, NULL} /* Sentinel */
1367 };
1368
1369
1370 static PyAsyncMethods async_gen_as_async = {
1371 0, /* am_await */
1372 PyObject_SelfIter, /* am_aiter */
1373 (unaryfunc)async_gen_anext /* am_anext */
1374 };
1375
1376
1377 PyTypeObject PyAsyncGen_Type = {
1378 PyVarObject_HEAD_INIT(&PyType_Type, 0)
1379 "async_generator", /* tp_name */
1380 sizeof(PyAsyncGenObject), /* tp_basicsize */
1381 0, /* tp_itemsize */
1382 /* methods */
1383 (destructor)gen_dealloc, /* tp_dealloc */
1384 0, /* tp_print */
1385 0, /* tp_getattr */
1386 0, /* tp_setattr */
1387 &async_gen_as_async, /* tp_as_async */
1388 (reprfunc)async_gen_repr, /* tp_repr */
1389 0, /* tp_as_number */
1390 0, /* tp_as_sequence */
1391 0, /* tp_as_mapping */
1392 0, /* tp_hash */
1393 0, /* tp_call */
1394 0, /* tp_str */
1395 PyObject_GenericGetAttr, /* tp_getattro */
1396 0, /* tp_setattro */
1397 0, /* tp_as_buffer */
1398 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
1399 Py_TPFLAGS_HAVE_FINALIZE, /* tp_flags */
1400 0, /* tp_doc */
1401 (traverseproc)async_gen_traverse, /* tp_traverse */
1402 0, /* tp_clear */
1403 0, /* tp_richcompare */
1404 offsetof(PyAsyncGenObject, ag_weakreflist), /* tp_weaklistoffset */
1405 0, /* tp_iter */
1406 0, /* tp_iternext */
1407 async_gen_methods, /* tp_methods */
1408 async_gen_memberlist, /* tp_members */
1409 async_gen_getsetlist, /* tp_getset */
1410 0, /* tp_base */
1411 0, /* tp_dict */
1412 0, /* tp_descr_get */
1413 0, /* tp_descr_set */
1414 0, /* tp_dictoffset */
1415 0, /* tp_init */
1416 0, /* tp_alloc */
1417 0, /* tp_new */
1418 0, /* tp_free */
1419 0, /* tp_is_gc */
1420 0, /* tp_bases */
1421 0, /* tp_mro */
1422 0, /* tp_cache */
1423 0, /* tp_subclasses */
1424 0, /* tp_weaklist */
1425 0, /* tp_del */
1426 0, /* tp_version_tag */
1427 _PyGen_Finalize, /* tp_finalize */
1428 };
1429
1430
1431 PyObject *
PyAsyncGen_New(PyFrameObject * f,PyObject * name,PyObject * qualname)1432 PyAsyncGen_New(PyFrameObject *f, PyObject *name, PyObject *qualname)
1433 {
1434 PyAsyncGenObject *o;
1435 o = (PyAsyncGenObject *)gen_new_with_qualname(
1436 &PyAsyncGen_Type, f, name, qualname);
1437 if (o == NULL) {
1438 return NULL;
1439 }
1440 o->ag_finalizer = NULL;
1441 o->ag_closed = 0;
1442 o->ag_hooks_inited = 0;
1443 return (PyObject*)o;
1444 }
1445
1446
1447 int
PyAsyncGen_ClearFreeLists(void)1448 PyAsyncGen_ClearFreeLists(void)
1449 {
1450 int ret = ag_value_freelist_free + ag_asend_freelist_free;
1451
1452 while (ag_value_freelist_free) {
1453 _PyAsyncGenWrappedValue *o;
1454 o = ag_value_freelist[--ag_value_freelist_free];
1455 assert(_PyAsyncGenWrappedValue_CheckExact(o));
1456 PyObject_GC_Del(o);
1457 }
1458
1459 while (ag_asend_freelist_free) {
1460 PyAsyncGenASend *o;
1461 o = ag_asend_freelist[--ag_asend_freelist_free];
1462 assert(Py_TYPE(o) == &_PyAsyncGenASend_Type);
1463 PyObject_GC_Del(o);
1464 }
1465
1466 return ret;
1467 }
1468
1469 void
PyAsyncGen_Fini(void)1470 PyAsyncGen_Fini(void)
1471 {
1472 PyAsyncGen_ClearFreeLists();
1473 }
1474
1475
1476 static PyObject *
async_gen_unwrap_value(PyAsyncGenObject * gen,PyObject * result)1477 async_gen_unwrap_value(PyAsyncGenObject *gen, PyObject *result)
1478 {
1479 if (result == NULL) {
1480 if (!PyErr_Occurred()) {
1481 PyErr_SetNone(PyExc_StopAsyncIteration);
1482 }
1483
1484 if (PyErr_ExceptionMatches(PyExc_StopAsyncIteration)
1485 || PyErr_ExceptionMatches(PyExc_GeneratorExit)
1486 ) {
1487 gen->ag_closed = 1;
1488 }
1489
1490 return NULL;
1491 }
1492
1493 if (_PyAsyncGenWrappedValue_CheckExact(result)) {
1494 /* async yield */
1495 _PyGen_SetStopIterationValue(((_PyAsyncGenWrappedValue*)result)->agw_val);
1496 Py_DECREF(result);
1497 return NULL;
1498 }
1499
1500 return result;
1501 }
1502
1503
1504 /* ---------- Async Generator ASend Awaitable ------------ */
1505
1506
1507 static void
async_gen_asend_dealloc(PyAsyncGenASend * o)1508 async_gen_asend_dealloc(PyAsyncGenASend *o)
1509 {
1510 _PyObject_GC_UNTRACK((PyObject *)o);
1511 Py_CLEAR(o->ags_gen);
1512 Py_CLEAR(o->ags_sendval);
1513 if (ag_asend_freelist_free < _PyAsyncGen_MAXFREELIST) {
1514 assert(PyAsyncGenASend_CheckExact(o));
1515 ag_asend_freelist[ag_asend_freelist_free++] = o;
1516 } else {
1517 PyObject_GC_Del(o);
1518 }
1519 }
1520
1521 static int
async_gen_asend_traverse(PyAsyncGenASend * o,visitproc visit,void * arg)1522 async_gen_asend_traverse(PyAsyncGenASend *o, visitproc visit, void *arg)
1523 {
1524 Py_VISIT(o->ags_gen);
1525 Py_VISIT(o->ags_sendval);
1526 return 0;
1527 }
1528
1529
1530 static PyObject *
async_gen_asend_send(PyAsyncGenASend * o,PyObject * arg)1531 async_gen_asend_send(PyAsyncGenASend *o, PyObject *arg)
1532 {
1533 PyObject *result;
1534
1535 if (o->ags_state == AWAITABLE_STATE_CLOSED) {
1536 PyErr_SetNone(PyExc_StopIteration);
1537 return NULL;
1538 }
1539
1540 if (o->ags_state == AWAITABLE_STATE_INIT) {
1541 if (arg == NULL || arg == Py_None) {
1542 arg = o->ags_sendval;
1543 }
1544 o->ags_state = AWAITABLE_STATE_ITER;
1545 }
1546
1547 result = gen_send_ex((PyGenObject*)o->ags_gen, arg, 0, 0);
1548 result = async_gen_unwrap_value(o->ags_gen, result);
1549
1550 if (result == NULL) {
1551 o->ags_state = AWAITABLE_STATE_CLOSED;
1552 }
1553
1554 return result;
1555 }
1556
1557
1558 static PyObject *
async_gen_asend_iternext(PyAsyncGenASend * o)1559 async_gen_asend_iternext(PyAsyncGenASend *o)
1560 {
1561 return async_gen_asend_send(o, NULL);
1562 }
1563
1564
1565 static PyObject *
async_gen_asend_throw(PyAsyncGenASend * o,PyObject * args)1566 async_gen_asend_throw(PyAsyncGenASend *o, PyObject *args)
1567 {
1568 PyObject *result;
1569
1570 if (o->ags_state == AWAITABLE_STATE_CLOSED) {
1571 PyErr_SetNone(PyExc_StopIteration);
1572 return NULL;
1573 }
1574
1575 result = gen_throw((PyGenObject*)o->ags_gen, args);
1576 result = async_gen_unwrap_value(o->ags_gen, result);
1577
1578 if (result == NULL) {
1579 o->ags_state = AWAITABLE_STATE_CLOSED;
1580 }
1581
1582 return result;
1583 }
1584
1585
1586 static PyObject *
async_gen_asend_close(PyAsyncGenASend * o,PyObject * args)1587 async_gen_asend_close(PyAsyncGenASend *o, PyObject *args)
1588 {
1589 o->ags_state = AWAITABLE_STATE_CLOSED;
1590 Py_RETURN_NONE;
1591 }
1592
1593
1594 static PyMethodDef async_gen_asend_methods[] = {
1595 {"send", (PyCFunction)async_gen_asend_send, METH_O, send_doc},
1596 {"throw", (PyCFunction)async_gen_asend_throw, METH_VARARGS, throw_doc},
1597 {"close", (PyCFunction)async_gen_asend_close, METH_NOARGS, close_doc},
1598 {NULL, NULL} /* Sentinel */
1599 };
1600
1601
1602 static PyAsyncMethods async_gen_asend_as_async = {
1603 PyObject_SelfIter, /* am_await */
1604 0, /* am_aiter */
1605 0 /* am_anext */
1606 };
1607
1608
1609 PyTypeObject _PyAsyncGenASend_Type = {
1610 PyVarObject_HEAD_INIT(&PyType_Type, 0)
1611 "async_generator_asend", /* tp_name */
1612 sizeof(PyAsyncGenASend), /* tp_basicsize */
1613 0, /* tp_itemsize */
1614 /* methods */
1615 (destructor)async_gen_asend_dealloc, /* tp_dealloc */
1616 0, /* tp_print */
1617 0, /* tp_getattr */
1618 0, /* tp_setattr */
1619 &async_gen_asend_as_async, /* tp_as_async */
1620 0, /* tp_repr */
1621 0, /* tp_as_number */
1622 0, /* tp_as_sequence */
1623 0, /* tp_as_mapping */
1624 0, /* tp_hash */
1625 0, /* tp_call */
1626 0, /* tp_str */
1627 PyObject_GenericGetAttr, /* tp_getattro */
1628 0, /* tp_setattro */
1629 0, /* tp_as_buffer */
1630 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
1631 0, /* tp_doc */
1632 (traverseproc)async_gen_asend_traverse, /* tp_traverse */
1633 0, /* tp_clear */
1634 0, /* tp_richcompare */
1635 0, /* tp_weaklistoffset */
1636 PyObject_SelfIter, /* tp_iter */
1637 (iternextfunc)async_gen_asend_iternext, /* tp_iternext */
1638 async_gen_asend_methods, /* tp_methods */
1639 0, /* tp_members */
1640 0, /* tp_getset */
1641 0, /* tp_base */
1642 0, /* tp_dict */
1643 0, /* tp_descr_get */
1644 0, /* tp_descr_set */
1645 0, /* tp_dictoffset */
1646 0, /* tp_init */
1647 0, /* tp_alloc */
1648 0, /* tp_new */
1649 };
1650
1651
1652 static PyObject *
async_gen_asend_new(PyAsyncGenObject * gen,PyObject * sendval)1653 async_gen_asend_new(PyAsyncGenObject *gen, PyObject *sendval)
1654 {
1655 PyAsyncGenASend *o;
1656 if (ag_asend_freelist_free) {
1657 ag_asend_freelist_free--;
1658 o = ag_asend_freelist[ag_asend_freelist_free];
1659 _Py_NewReference((PyObject *)o);
1660 } else {
1661 o = PyObject_GC_New(PyAsyncGenASend, &_PyAsyncGenASend_Type);
1662 if (o == NULL) {
1663 return NULL;
1664 }
1665 }
1666
1667 Py_INCREF(gen);
1668 o->ags_gen = gen;
1669
1670 Py_XINCREF(sendval);
1671 o->ags_sendval = sendval;
1672
1673 o->ags_state = AWAITABLE_STATE_INIT;
1674
1675 _PyObject_GC_TRACK((PyObject*)o);
1676 return (PyObject*)o;
1677 }
1678
1679
1680 /* ---------- Async Generator Value Wrapper ------------ */
1681
1682
1683 static void
async_gen_wrapped_val_dealloc(_PyAsyncGenWrappedValue * o)1684 async_gen_wrapped_val_dealloc(_PyAsyncGenWrappedValue *o)
1685 {
1686 _PyObject_GC_UNTRACK((PyObject *)o);
1687 Py_CLEAR(o->agw_val);
1688 if (ag_value_freelist_free < _PyAsyncGen_MAXFREELIST) {
1689 assert(_PyAsyncGenWrappedValue_CheckExact(o));
1690 ag_value_freelist[ag_value_freelist_free++] = o;
1691 } else {
1692 PyObject_GC_Del(o);
1693 }
1694 }
1695
1696
1697 static int
async_gen_wrapped_val_traverse(_PyAsyncGenWrappedValue * o,visitproc visit,void * arg)1698 async_gen_wrapped_val_traverse(_PyAsyncGenWrappedValue *o,
1699 visitproc visit, void *arg)
1700 {
1701 Py_VISIT(o->agw_val);
1702 return 0;
1703 }
1704
1705
1706 PyTypeObject _PyAsyncGenWrappedValue_Type = {
1707 PyVarObject_HEAD_INIT(&PyType_Type, 0)
1708 "async_generator_wrapped_value", /* tp_name */
1709 sizeof(_PyAsyncGenWrappedValue), /* tp_basicsize */
1710 0, /* tp_itemsize */
1711 /* methods */
1712 (destructor)async_gen_wrapped_val_dealloc, /* tp_dealloc */
1713 0, /* tp_print */
1714 0, /* tp_getattr */
1715 0, /* tp_setattr */
1716 0, /* tp_as_async */
1717 0, /* tp_repr */
1718 0, /* tp_as_number */
1719 0, /* tp_as_sequence */
1720 0, /* tp_as_mapping */
1721 0, /* tp_hash */
1722 0, /* tp_call */
1723 0, /* tp_str */
1724 PyObject_GenericGetAttr, /* tp_getattro */
1725 0, /* tp_setattro */
1726 0, /* tp_as_buffer */
1727 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
1728 0, /* tp_doc */
1729 (traverseproc)async_gen_wrapped_val_traverse, /* tp_traverse */
1730 0, /* tp_clear */
1731 0, /* tp_richcompare */
1732 0, /* tp_weaklistoffset */
1733 0, /* tp_iter */
1734 0, /* tp_iternext */
1735 0, /* tp_methods */
1736 0, /* tp_members */
1737 0, /* tp_getset */
1738 0, /* tp_base */
1739 0, /* tp_dict */
1740 0, /* tp_descr_get */
1741 0, /* tp_descr_set */
1742 0, /* tp_dictoffset */
1743 0, /* tp_init */
1744 0, /* tp_alloc */
1745 0, /* tp_new */
1746 };
1747
1748
1749 PyObject *
_PyAsyncGenValueWrapperNew(PyObject * val)1750 _PyAsyncGenValueWrapperNew(PyObject *val)
1751 {
1752 _PyAsyncGenWrappedValue *o;
1753 assert(val);
1754
1755 if (ag_value_freelist_free) {
1756 ag_value_freelist_free--;
1757 o = ag_value_freelist[ag_value_freelist_free];
1758 assert(_PyAsyncGenWrappedValue_CheckExact(o));
1759 _Py_NewReference((PyObject*)o);
1760 } else {
1761 o = PyObject_GC_New(_PyAsyncGenWrappedValue,
1762 &_PyAsyncGenWrappedValue_Type);
1763 if (o == NULL) {
1764 return NULL;
1765 }
1766 }
1767 o->agw_val = val;
1768 Py_INCREF(val);
1769 _PyObject_GC_TRACK((PyObject*)o);
1770 return (PyObject*)o;
1771 }
1772
1773
1774 /* ---------- Async Generator AThrow awaitable ------------ */
1775
1776
1777 static void
async_gen_athrow_dealloc(PyAsyncGenAThrow * o)1778 async_gen_athrow_dealloc(PyAsyncGenAThrow *o)
1779 {
1780 _PyObject_GC_UNTRACK((PyObject *)o);
1781 Py_CLEAR(o->agt_gen);
1782 Py_CLEAR(o->agt_args);
1783 PyObject_GC_Del(o);
1784 }
1785
1786
1787 static int
async_gen_athrow_traverse(PyAsyncGenAThrow * o,visitproc visit,void * arg)1788 async_gen_athrow_traverse(PyAsyncGenAThrow *o, visitproc visit, void *arg)
1789 {
1790 Py_VISIT(o->agt_gen);
1791 Py_VISIT(o->agt_args);
1792 return 0;
1793 }
1794
1795
1796 static PyObject *
async_gen_athrow_send(PyAsyncGenAThrow * o,PyObject * arg)1797 async_gen_athrow_send(PyAsyncGenAThrow *o, PyObject *arg)
1798 {
1799 PyGenObject *gen = (PyGenObject*)o->agt_gen;
1800 PyFrameObject *f = gen->gi_frame;
1801 PyObject *retval;
1802
1803 if (f == NULL || f->f_stacktop == NULL ||
1804 o->agt_state == AWAITABLE_STATE_CLOSED) {
1805 PyErr_SetNone(PyExc_StopIteration);
1806 return NULL;
1807 }
1808
1809 if (o->agt_state == AWAITABLE_STATE_INIT) {
1810 if (o->agt_gen->ag_closed) {
1811 PyErr_SetNone(PyExc_StopIteration);
1812 return NULL;
1813 }
1814
1815 if (arg != Py_None) {
1816 PyErr_SetString(PyExc_RuntimeError, NON_INIT_CORO_MSG);
1817 return NULL;
1818 }
1819
1820 o->agt_state = AWAITABLE_STATE_ITER;
1821
1822 if (o->agt_args == NULL) {
1823 /* aclose() mode */
1824 o->agt_gen->ag_closed = 1;
1825
1826 retval = _gen_throw((PyGenObject *)gen,
1827 0, /* Do not close generator when
1828 PyExc_GeneratorExit is passed */
1829 PyExc_GeneratorExit, NULL, NULL);
1830
1831 if (retval && _PyAsyncGenWrappedValue_CheckExact(retval)) {
1832 Py_DECREF(retval);
1833 goto yield_close;
1834 }
1835 } else {
1836 PyObject *typ;
1837 PyObject *tb = NULL;
1838 PyObject *val = NULL;
1839
1840 if (!PyArg_UnpackTuple(o->agt_args, "athrow", 1, 3,
1841 &typ, &val, &tb)) {
1842 return NULL;
1843 }
1844
1845 retval = _gen_throw((PyGenObject *)gen,
1846 0, /* Do not close generator when
1847 PyExc_GeneratorExit is passed */
1848 typ, val, tb);
1849 retval = async_gen_unwrap_value(o->agt_gen, retval);
1850 }
1851 if (retval == NULL) {
1852 goto check_error;
1853 }
1854 return retval;
1855 }
1856
1857 assert(o->agt_state == AWAITABLE_STATE_ITER);
1858
1859 retval = gen_send_ex((PyGenObject *)gen, arg, 0, 0);
1860 if (o->agt_args) {
1861 return async_gen_unwrap_value(o->agt_gen, retval);
1862 } else {
1863 /* aclose() mode */
1864 if (retval) {
1865 if (_PyAsyncGenWrappedValue_CheckExact(retval)) {
1866 Py_DECREF(retval);
1867 goto yield_close;
1868 }
1869 else {
1870 return retval;
1871 }
1872 }
1873 else {
1874 goto check_error;
1875 }
1876 }
1877
1878 yield_close:
1879 PyErr_SetString(
1880 PyExc_RuntimeError, ASYNC_GEN_IGNORED_EXIT_MSG);
1881 return NULL;
1882
1883 check_error:
1884 if (PyErr_ExceptionMatches(PyExc_StopAsyncIteration)) {
1885 o->agt_state = AWAITABLE_STATE_CLOSED;
1886 if (o->agt_args == NULL) {
1887 /* when aclose() is called we don't want to propagate
1888 StopAsyncIteration; just raise StopIteration, signalling
1889 that 'aclose()' is done. */
1890 PyErr_Clear();
1891 PyErr_SetNone(PyExc_StopIteration);
1892 }
1893 }
1894 else if (PyErr_ExceptionMatches(PyExc_GeneratorExit)) {
1895 o->agt_state = AWAITABLE_STATE_CLOSED;
1896 PyErr_Clear(); /* ignore these errors */
1897 PyErr_SetNone(PyExc_StopIteration);
1898 }
1899 return NULL;
1900 }
1901
1902
1903 static PyObject *
async_gen_athrow_throw(PyAsyncGenAThrow * o,PyObject * args)1904 async_gen_athrow_throw(PyAsyncGenAThrow *o, PyObject *args)
1905 {
1906 PyObject *retval;
1907
1908 if (o->agt_state == AWAITABLE_STATE_INIT) {
1909 PyErr_SetString(PyExc_RuntimeError, NON_INIT_CORO_MSG);
1910 return NULL;
1911 }
1912
1913 if (o->agt_state == AWAITABLE_STATE_CLOSED) {
1914 PyErr_SetNone(PyExc_StopIteration);
1915 return NULL;
1916 }
1917
1918 retval = gen_throw((PyGenObject*)o->agt_gen, args);
1919 if (o->agt_args) {
1920 return async_gen_unwrap_value(o->agt_gen, retval);
1921 } else {
1922 /* aclose() mode */
1923 if (retval && _PyAsyncGenWrappedValue_CheckExact(retval)) {
1924 Py_DECREF(retval);
1925 PyErr_SetString(PyExc_RuntimeError, ASYNC_GEN_IGNORED_EXIT_MSG);
1926 return NULL;
1927 }
1928 return retval;
1929 }
1930 }
1931
1932
1933 static PyObject *
async_gen_athrow_iternext(PyAsyncGenAThrow * o)1934 async_gen_athrow_iternext(PyAsyncGenAThrow *o)
1935 {
1936 return async_gen_athrow_send(o, Py_None);
1937 }
1938
1939
1940 static PyObject *
async_gen_athrow_close(PyAsyncGenAThrow * o,PyObject * args)1941 async_gen_athrow_close(PyAsyncGenAThrow *o, PyObject *args)
1942 {
1943 o->agt_state = AWAITABLE_STATE_CLOSED;
1944 Py_RETURN_NONE;
1945 }
1946
1947
1948 static PyMethodDef async_gen_athrow_methods[] = {
1949 {"send", (PyCFunction)async_gen_athrow_send, METH_O, send_doc},
1950 {"throw", (PyCFunction)async_gen_athrow_throw, METH_VARARGS, throw_doc},
1951 {"close", (PyCFunction)async_gen_athrow_close, METH_NOARGS, close_doc},
1952 {NULL, NULL} /* Sentinel */
1953 };
1954
1955
1956 static PyAsyncMethods async_gen_athrow_as_async = {
1957 PyObject_SelfIter, /* am_await */
1958 0, /* am_aiter */
1959 0 /* am_anext */
1960 };
1961
1962
1963 PyTypeObject _PyAsyncGenAThrow_Type = {
1964 PyVarObject_HEAD_INIT(&PyType_Type, 0)
1965 "async_generator_athrow", /* tp_name */
1966 sizeof(PyAsyncGenAThrow), /* tp_basicsize */
1967 0, /* tp_itemsize */
1968 /* methods */
1969 (destructor)async_gen_athrow_dealloc, /* tp_dealloc */
1970 0, /* tp_print */
1971 0, /* tp_getattr */
1972 0, /* tp_setattr */
1973 &async_gen_athrow_as_async, /* tp_as_async */
1974 0, /* tp_repr */
1975 0, /* tp_as_number */
1976 0, /* tp_as_sequence */
1977 0, /* tp_as_mapping */
1978 0, /* tp_hash */
1979 0, /* tp_call */
1980 0, /* tp_str */
1981 PyObject_GenericGetAttr, /* tp_getattro */
1982 0, /* tp_setattro */
1983 0, /* tp_as_buffer */
1984 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
1985 0, /* tp_doc */
1986 (traverseproc)async_gen_athrow_traverse, /* tp_traverse */
1987 0, /* tp_clear */
1988 0, /* tp_richcompare */
1989 0, /* tp_weaklistoffset */
1990 PyObject_SelfIter, /* tp_iter */
1991 (iternextfunc)async_gen_athrow_iternext, /* tp_iternext */
1992 async_gen_athrow_methods, /* tp_methods */
1993 0, /* tp_members */
1994 0, /* tp_getset */
1995 0, /* tp_base */
1996 0, /* tp_dict */
1997 0, /* tp_descr_get */
1998 0, /* tp_descr_set */
1999 0, /* tp_dictoffset */
2000 0, /* tp_init */
2001 0, /* tp_alloc */
2002 0, /* tp_new */
2003 };
2004
2005
2006 static PyObject *
async_gen_athrow_new(PyAsyncGenObject * gen,PyObject * args)2007 async_gen_athrow_new(PyAsyncGenObject *gen, PyObject *args)
2008 {
2009 PyAsyncGenAThrow *o;
2010 o = PyObject_GC_New(PyAsyncGenAThrow, &_PyAsyncGenAThrow_Type);
2011 if (o == NULL) {
2012 return NULL;
2013 }
2014 o->agt_gen = gen;
2015 o->agt_args = args;
2016 o->agt_state = AWAITABLE_STATE_INIT;
2017 Py_INCREF(gen);
2018 Py_XINCREF(args);
2019 _PyObject_GC_TRACK((PyObject*)o);
2020 return (PyObject*)o;
2021 }
2022