--- /dev/null
+/* Generator object implementation */\r
+\r
+#include "Python.h"\r
+#include "frameobject.h"\r
+#include "genobject.h"\r
+#include "ceval.h"\r
+#include "structmember.h"\r
+#include "opcode.h"\r
+\r
+static int\r
+gen_traverse(PyGenObject *gen, visitproc visit, void *arg)\r
+{\r
+ Py_VISIT((PyObject *)gen->gi_frame);\r
+ Py_VISIT(gen->gi_code);\r
+ return 0;\r
+}\r
+\r
+static void\r
+gen_dealloc(PyGenObject *gen)\r
+{\r
+ PyObject *self = (PyObject *) gen;\r
+\r
+ _PyObject_GC_UNTRACK(gen);\r
+\r
+ if (gen->gi_weakreflist != NULL)\r
+ PyObject_ClearWeakRefs(self);\r
+\r
+ _PyObject_GC_TRACK(self);\r
+\r
+ if (gen->gi_frame != NULL && gen->gi_frame->f_stacktop != NULL) {\r
+ /* Generator is paused, so we need to close */\r
+ Py_TYPE(gen)->tp_del(self);\r
+ if (self->ob_refcnt > 0)\r
+ return; /* resurrected. :( */\r
+ }\r
+\r
+ _PyObject_GC_UNTRACK(self);\r
+ Py_CLEAR(gen->gi_frame);\r
+ Py_CLEAR(gen->gi_code);\r
+ PyObject_GC_Del(gen);\r
+}\r
+\r
+\r
+static PyObject *\r
+gen_send_ex(PyGenObject *gen, PyObject *arg, int exc)\r
+{\r
+ PyThreadState *tstate = PyThreadState_GET();\r
+ PyFrameObject *f = gen->gi_frame;\r
+ PyObject *result;\r
+\r
+ if (gen->gi_running) {\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "generator already executing");\r
+ return NULL;\r
+ }\r
+ if (f==NULL || f->f_stacktop == NULL) {\r
+ /* Only set exception if called from send() */\r
+ if (arg && !exc)\r
+ PyErr_SetNone(PyExc_StopIteration);\r
+ return NULL;\r
+ }\r
+\r
+ if (f->f_lasti == -1) {\r
+ if (arg && arg != Py_None) {\r
+ PyErr_SetString(PyExc_TypeError,\r
+ "can't send non-None value to a "\r
+ "just-started generator");\r
+ return NULL;\r
+ }\r
+ } else {\r
+ /* Push arg onto the frame's value stack */\r
+ result = arg ? arg : Py_None;\r
+ Py_INCREF(result);\r
+ *(f->f_stacktop++) = result;\r
+ }\r
+\r
+ /* Generators always return to their most recent caller, not\r
+ * necessarily their creator. */\r
+ f->f_tstate = tstate;\r
+ Py_XINCREF(tstate->frame);\r
+ assert(f->f_back == NULL);\r
+ f->f_back = tstate->frame;\r
+\r
+ gen->gi_running = 1;\r
+ result = PyEval_EvalFrameEx(f, exc);\r
+ gen->gi_running = 0;\r
+\r
+ /* Don't keep the reference to f_back any longer than necessary. It\r
+ * may keep a chain of frames alive or it could create a reference\r
+ * cycle. */\r
+ assert(f->f_back == tstate->frame);\r
+ Py_CLEAR(f->f_back);\r
+ /* Clear the borrowed reference to the thread state */\r
+ f->f_tstate = NULL;\r
+\r
+ /* If the generator just returned (as opposed to yielding), signal\r
+ * that the generator is exhausted. */\r
+ if (result == Py_None && f->f_stacktop == NULL) {\r
+ Py_DECREF(result);\r
+ result = NULL;\r
+ /* Set exception if not called by gen_iternext() */\r
+ if (arg)\r
+ PyErr_SetNone(PyExc_StopIteration);\r
+ }\r
+\r
+ if (!result || f->f_stacktop == NULL) {\r
+ /* generator can't be rerun, so release the frame */\r
+ Py_DECREF(f);\r
+ gen->gi_frame = NULL;\r
+ }\r
+\r
+ return result;\r
+}\r
+\r
+PyDoc_STRVAR(send_doc,\r
+"send(arg) -> send 'arg' into generator,\n\\r
+return next yielded value or raise StopIteration.");\r
+\r
+static PyObject *\r
+gen_send(PyGenObject *gen, PyObject *arg)\r
+{\r
+ return gen_send_ex(gen, arg, 0);\r
+}\r
+\r
+PyDoc_STRVAR(close_doc,\r
+"close() -> raise GeneratorExit inside generator.");\r
+\r
+static PyObject *\r
+gen_close(PyGenObject *gen, PyObject *args)\r
+{\r
+ PyObject *retval;\r
+ PyErr_SetNone(PyExc_GeneratorExit);\r
+ retval = gen_send_ex(gen, Py_None, 1);\r
+ if (retval) {\r
+ Py_DECREF(retval);\r
+ PyErr_SetString(PyExc_RuntimeError,\r
+ "generator ignored GeneratorExit");\r
+ return NULL;\r
+ }\r
+ if (PyErr_ExceptionMatches(PyExc_StopIteration)\r
+ || PyErr_ExceptionMatches(PyExc_GeneratorExit))\r
+ {\r
+ PyErr_Clear(); /* ignore these errors */\r
+ Py_INCREF(Py_None);\r
+ return Py_None;\r
+ }\r
+ return NULL;\r
+}\r
+\r
+static void\r
+gen_del(PyObject *self)\r
+{\r
+ PyObject *res;\r
+ PyObject *error_type, *error_value, *error_traceback;\r
+ PyGenObject *gen = (PyGenObject *)self;\r
+\r
+ if (gen->gi_frame == NULL || gen->gi_frame->f_stacktop == NULL)\r
+ /* Generator isn't paused, so no need to close */\r
+ return;\r
+\r
+ /* Temporarily resurrect the object. */\r
+ assert(self->ob_refcnt == 0);\r
+ self->ob_refcnt = 1;\r
+\r
+ /* Save the current exception, if any. */\r
+ PyErr_Fetch(&error_type, &error_value, &error_traceback);\r
+\r
+ res = gen_close(gen, NULL);\r
+\r
+ if (res == NULL)\r
+ PyErr_WriteUnraisable(self);\r
+ else\r
+ Py_DECREF(res);\r
+\r
+ /* Restore the saved exception. */\r
+ PyErr_Restore(error_type, error_value, error_traceback);\r
+\r
+ /* Undo the temporary resurrection; can't use DECREF here, it would\r
+ * cause a recursive call.\r
+ */\r
+ assert(self->ob_refcnt > 0);\r
+ if (--self->ob_refcnt == 0)\r
+ return; /* this is the normal path out */\r
+\r
+ /* close() resurrected it! Make it look like the original Py_DECREF\r
+ * never happened.\r
+ */\r
+ {\r
+ Py_ssize_t refcnt = self->ob_refcnt;\r
+ _Py_NewReference(self);\r
+ self->ob_refcnt = refcnt;\r
+ }\r
+ assert(PyType_IS_GC(self->ob_type) &&\r
+ _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED);\r
+\r
+ /* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so\r
+ * we need to undo that. */\r
+ _Py_DEC_REFTOTAL;\r
+ /* If Py_TRACE_REFS, _Py_NewReference re-added self to the object\r
+ * chain, so no more to do there.\r
+ * If COUNT_ALLOCS, the original decref bumped tp_frees, and\r
+ * _Py_NewReference bumped tp_allocs: both of those need to be\r
+ * undone.\r
+ */\r
+#ifdef COUNT_ALLOCS\r
+ --self->ob_type->tp_frees;\r
+ --self->ob_type->tp_allocs;\r
+#endif\r
+}\r
+\r
+\r
+\r
+PyDoc_STRVAR(throw_doc,\r
+"throw(typ[,val[,tb]]) -> raise exception in generator,\n\\r
+return next yielded value or raise StopIteration.");\r
+\r
+static PyObject *\r
+gen_throw(PyGenObject *gen, PyObject *args)\r
+{\r
+ PyObject *typ;\r
+ PyObject *tb = NULL;\r
+ PyObject *val = NULL;\r
+\r
+ if (!PyArg_UnpackTuple(args, "throw", 1, 3, &typ, &val, &tb))\r
+ return NULL;\r
+\r
+ /* First, check the traceback argument, replacing None with\r
+ NULL. */\r
+ if (tb == Py_None)\r
+ tb = NULL;\r
+ else if (tb != NULL && !PyTraceBack_Check(tb)) {\r
+ PyErr_SetString(PyExc_TypeError,\r
+ "throw() third argument must be a traceback object");\r
+ return NULL;\r
+ }\r
+\r
+ Py_INCREF(typ);\r
+ Py_XINCREF(val);\r
+ Py_XINCREF(tb);\r
+\r
+ if (PyExceptionClass_Check(typ)) {\r
+ PyErr_NormalizeException(&typ, &val, &tb);\r
+ }\r
+\r
+ else if (PyExceptionInstance_Check(typ)) {\r
+ /* Raising an instance. The value should be a dummy. */\r
+ if (val && val != Py_None) {\r
+ PyErr_SetString(PyExc_TypeError,\r
+ "instance exception may not have a separate value");\r
+ goto failed_throw;\r
+ }\r
+ else {\r
+ /* Normalize to raise <class>, <instance> */\r
+ Py_XDECREF(val);\r
+ val = typ;\r
+ typ = PyExceptionInstance_Class(typ);\r
+ Py_INCREF(typ);\r
+ }\r
+ }\r
+ else {\r
+ /* Not something you can raise. throw() fails. */\r
+ PyErr_Format(PyExc_TypeError,\r
+ "exceptions must be classes, or instances, not %s",\r
+ typ->ob_type->tp_name);\r
+ goto failed_throw;\r
+ }\r
+\r
+ PyErr_Restore(typ, val, tb);\r
+ return gen_send_ex(gen, Py_None, 1);\r
+\r
+failed_throw:\r
+ /* Didn't use our arguments, so restore their original refcounts */\r
+ Py_DECREF(typ);\r
+ Py_XDECREF(val);\r
+ Py_XDECREF(tb);\r
+ return NULL;\r
+}\r
+\r
+\r
+static PyObject *\r
+gen_iternext(PyGenObject *gen)\r
+{\r
+ return gen_send_ex(gen, NULL, 0);\r
+}\r
+\r
+\r
+static PyObject *\r
+gen_repr(PyGenObject *gen)\r
+{\r
+ char *code_name;\r
+ code_name = PyString_AsString(((PyCodeObject *)gen->gi_code)->co_name);\r
+ if (code_name == NULL)\r
+ return NULL;\r
+ return PyString_FromFormat("<generator object %.200s at %p>",\r
+ code_name, gen);\r
+}\r
+\r
+\r
+static PyObject *\r
+gen_get_name(PyGenObject *gen)\r
+{\r
+ PyObject *name = ((PyCodeObject *)gen->gi_code)->co_name;\r
+ Py_INCREF(name);\r
+ return name;\r
+}\r
+\r
+\r
+PyDoc_STRVAR(gen__name__doc__,\r
+"Return the name of the generator's associated code object.");\r
+\r
+static PyGetSetDef gen_getsetlist[] = {\r
+ {"__name__", (getter)gen_get_name, NULL, gen__name__doc__},\r
+ {NULL}\r
+};\r
+\r
+\r
+static PyMemberDef gen_memberlist[] = {\r
+ {"gi_frame", T_OBJECT, offsetof(PyGenObject, gi_frame), RO},\r
+ {"gi_running", T_INT, offsetof(PyGenObject, gi_running), RO},\r
+ {"gi_code", T_OBJECT, offsetof(PyGenObject, gi_code), RO},\r
+ {NULL} /* Sentinel */\r
+};\r
+\r
+static PyMethodDef gen_methods[] = {\r
+ {"send",(PyCFunction)gen_send, METH_O, send_doc},\r
+ {"throw",(PyCFunction)gen_throw, METH_VARARGS, throw_doc},\r
+ {"close",(PyCFunction)gen_close, METH_NOARGS, close_doc},\r
+ {NULL, NULL} /* Sentinel */\r
+};\r
+\r
+PyTypeObject PyGen_Type = {\r
+ PyVarObject_HEAD_INIT(&PyType_Type, 0)\r
+ "generator", /* tp_name */\r
+ sizeof(PyGenObject), /* tp_basicsize */\r
+ 0, /* tp_itemsize */\r
+ /* methods */\r
+ (destructor)gen_dealloc, /* tp_dealloc */\r
+ 0, /* tp_print */\r
+ 0, /* tp_getattr */\r
+ 0, /* tp_setattr */\r
+ 0, /* tp_compare */\r
+ (reprfunc)gen_repr, /* tp_repr */\r
+ 0, /* tp_as_number */\r
+ 0, /* tp_as_sequence */\r
+ 0, /* tp_as_mapping */\r
+ 0, /* tp_hash */\r
+ 0, /* tp_call */\r
+ 0, /* tp_str */\r
+ PyObject_GenericGetAttr, /* tp_getattro */\r
+ 0, /* tp_setattro */\r
+ 0, /* tp_as_buffer */\r
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */\r
+ 0, /* tp_doc */\r
+ (traverseproc)gen_traverse, /* tp_traverse */\r
+ 0, /* tp_clear */\r
+ 0, /* tp_richcompare */\r
+ offsetof(PyGenObject, gi_weakreflist), /* tp_weaklistoffset */\r
+ PyObject_SelfIter, /* tp_iter */\r
+ (iternextfunc)gen_iternext, /* tp_iternext */\r
+ gen_methods, /* tp_methods */\r
+ gen_memberlist, /* tp_members */\r
+ gen_getsetlist, /* tp_getset */\r
+ 0, /* tp_base */\r
+ 0, /* tp_dict */\r
+\r
+ 0, /* tp_descr_get */\r
+ 0, /* tp_descr_set */\r
+ 0, /* tp_dictoffset */\r
+ 0, /* tp_init */\r
+ 0, /* tp_alloc */\r
+ 0, /* tp_new */\r
+ 0, /* tp_free */\r
+ 0, /* tp_is_gc */\r
+ 0, /* tp_bases */\r
+ 0, /* tp_mro */\r
+ 0, /* tp_cache */\r
+ 0, /* tp_subclasses */\r
+ 0, /* tp_weaklist */\r
+ gen_del, /* tp_del */\r
+};\r
+\r
+PyObject *\r
+PyGen_New(PyFrameObject *f)\r
+{\r
+ PyGenObject *gen = PyObject_GC_New(PyGenObject, &PyGen_Type);\r
+ if (gen == NULL) {\r
+ Py_DECREF(f);\r
+ return NULL;\r
+ }\r
+ gen->gi_frame = f;\r
+ Py_INCREF(f->f_code);\r
+ gen->gi_code = (PyObject *)(f->f_code);\r
+ gen->gi_running = 0;\r
+ gen->gi_weakreflist = NULL;\r
+ _PyObject_GC_TRACK(gen);\r
+ return (PyObject *)gen;\r
+}\r
+\r
+int\r
+PyGen_NeedsFinalizing(PyGenObject *gen)\r
+{\r
+ int i;\r
+ PyFrameObject *f = gen->gi_frame;\r
+\r
+ if (f == NULL || f->f_stacktop == NULL || f->f_iblock <= 0)\r
+ return 0; /* no frame or empty blockstack == no finalization */\r
+\r
+ /* Any block type besides a loop requires cleanup. */\r
+ i = f->f_iblock;\r
+ while (--i >= 0) {\r
+ if (f->f_blockstack[i].b_type != SETUP_LOOP)\r
+ return 1;\r
+ }\r
+\r
+ /* No blocks except loops, it's safe to skip finalization. */\r
+ return 0;\r
+}\r