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 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 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 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 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 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 * 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 * 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 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 * 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 * 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 * 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 * 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 * 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 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 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 * 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 * 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 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 * 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 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 * 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 * 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 * 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 * 817 PyGen_New(PyFrameObject *f) 818 { 819 return gen_new_with_qualname(&PyGen_Type, f, NULL, NULL); 820 } 821 822 int 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 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 * 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 * 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 * 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 * 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 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 * 1042 coro_wrapper_iternext(PyCoroWrapper *cw) 1043 { 1044 return gen_send_ex((PyGenObject *)cw->cw_coroutine, NULL, 0, 0); 1045 } 1046 1047 static PyObject * 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 * 1054 coro_wrapper_throw(PyCoroWrapper *cw, PyObject *args) 1055 { 1056 return gen_throw((PyGenObject *)cw->cw_coroutine, args); 1057 } 1058 1059 static PyObject * 1060 coro_wrapper_close(PyCoroWrapper *cw, PyObject *args) 1061 { 1062 return gen_close((PyGenObject *)cw->cw_coroutine, args); 1063 } 1064 1065 static int 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 * 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 * 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 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 * 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 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 * 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 * 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 * 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 * 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 * 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 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 1470 PyAsyncGen_Fini(void) 1471 { 1472 PyAsyncGen_ClearFreeLists(); 1473 } 1474 1475 1476 static PyObject * 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 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 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 * 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 * 1559 async_gen_asend_iternext(PyAsyncGenASend *o) 1560 { 1561 return async_gen_asend_send(o, NULL); 1562 } 1563 1564 1565 static PyObject * 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 * 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 * 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 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 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 * 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 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 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 * 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 * 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 * 1934 async_gen_athrow_iternext(PyAsyncGenAThrow *o) 1935 { 1936 return async_gen_athrow_send(o, Py_None); 1937 } 1938 1939 1940 static PyObject * 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 * 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
