[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Objects / genobject.c

/* 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
    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
\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(arg) -> 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
Commit	Line	Data
4710c53d	1	/* Generator object implementation */\r
	2	\r
	3	#include "Python.h"\r
	4	#include "frameobject.h"\r
	5	#include "genobject.h"\r
	6	#include "ceval.h"\r
	7	#include "structmember.h"\r
	8	#include "opcode.h"\r
	9	\r
	10	static int\r
	11	gen_traverse(PyGenObject gen, visitproc visit, void arg)\r
	12	{\r
	13	Py_VISIT((PyObject *)gen->gi_frame);\r
	14	Py_VISIT(gen->gi_code);\r
	15	return 0;\r
	16	}\r
	17	\r
	18	static void\r
	19	gen_dealloc(PyGenObject *gen)\r
	20	{\r
	21	PyObject self = (PyObject ) gen;\r
	22	\r
	23	_PyObject_GC_UNTRACK(gen);\r
	24	\r
	25	if (gen->gi_weakreflist != NULL)\r
	26	PyObject_ClearWeakRefs(self);\r
	27	\r
	28	_PyObject_GC_TRACK(self);\r
	29	\r
	30	if (gen->gi_frame != NULL && gen->gi_frame->f_stacktop != NULL) {\r
	31	/* Generator is paused, so we need to close */\r
	32	Py_TYPE(gen)->tp_del(self);\r
	33	if (self->ob_refcnt > 0)\r
	34	return; /* resurrected. :( */\r
	35	}\r
	36	\r
	37	_PyObject_GC_UNTRACK(self);\r
	38	Py_CLEAR(gen->gi_frame);\r
	39	Py_CLEAR(gen->gi_code);\r
	40	PyObject_GC_Del(gen);\r
	41	}\r
	42	\r
	43	\r
	44	static PyObject *\r
	45	gen_send_ex(PyGenObject gen, PyObject arg, int exc)\r
	46	{\r
	47	PyThreadState *tstate = PyThreadState_GET();\r
	48	PyFrameObject *f = gen->gi_frame;\r
	49	PyObject *result;\r
	50	\r
	51	if (gen->gi_running) {\r
	52	PyErr_SetString(PyExc_ValueError,\r
	53	"generator already executing");\r
	54	return NULL;\r
	55	}\r
	56	if (f==NULL \|\| f->f_stacktop == NULL) {\r
	57	/* Only set exception if called from send() */\r
	58	if (arg && !exc)\r
	59	PyErr_SetNone(PyExc_StopIteration);\r
	60	return NULL;\r
	61	}\r
	62	\r
	63	if (f->f_lasti == -1) {\r
	64	if (arg && arg != Py_None) {\r
65	PyErr_SetString(PyExc_TypeError,\r
66	"can't send non-None value to a "\r
67	"just-started generator");\r
68	return NULL;\r
69	}\r
70	} else {\r
71	/* Push arg onto the frame's value stack */\r
72	result = arg ? arg : Py_None;\r
73	Py_INCREF(result);\r
74	*(f->f_stacktop++) = result;\r
75	}\r
76	\r
77	/* Generators always return to their most recent caller, not\r
78	* necessarily their creator. */\r
79	Py_XINCREF(tstate->frame);\r
80	assert(f->f_back == NULL);\r
81	f->f_back = tstate->frame;\r
82	\r
83	gen->gi_running = 1;\r
84	result = PyEval_EvalFrameEx(f, exc);\r
85	gen->gi_running = 0;\r
86	\r
87	/* Don't keep the reference to f_back any longer than necessary. It\r
88	* may keep a chain of frames alive or it could create a reference\r
89	* cycle. */\r
90	assert(f->f_back == tstate->frame);\r
91	Py_CLEAR(f->f_back);\r
92	\r
93	/* If the generator just returned (as opposed to yielding), signal\r
94	* that the generator is exhausted. */\r
95	if (result == Py_None && f->f_stacktop == NULL) {\r
96	Py_DECREF(result);\r
97	result = NULL;\r
98	/* Set exception if not called by gen_iternext() */\r
99	if (arg)\r
100	PyErr_SetNone(PyExc_StopIteration);\r
101	}\r
102	\r
103	if (!result \|\| f->f_stacktop == NULL) {\r
104	/* generator can't be rerun, so release the frame */\r
105	Py_DECREF(f);\r
106	gen->gi_frame = NULL;\r
107	}\r
108	\r
109	return result;\r
110	}\r
111	\r
112	PyDoc_STRVAR(send_doc,\r
113	"send(arg) -> send 'arg' into generator,\n\\r
114	return next yielded value or raise StopIteration.");\r
115	\r
116	static PyObject *\r
117	gen_send(PyGenObject gen, PyObject arg)\r
118	{\r
119	return gen_send_ex(gen, arg, 0);\r
120	}\r
121	\r
122	PyDoc_STRVAR(close_doc,\r
123	"close(arg) -> raise GeneratorExit inside generator.");\r
124	\r
125	static PyObject *\r
126	gen_close(PyGenObject gen, PyObject args)\r
127	{\r
128	PyObject *retval;\r
129	PyErr_SetNone(PyExc_GeneratorExit);\r
130	retval = gen_send_ex(gen, Py_None, 1);\r
131	if (retval) {\r
132	Py_DECREF(retval);\r
133	PyErr_SetString(PyExc_RuntimeError,\r
134	"generator ignored GeneratorExit");\r
135	return NULL;\r
136	}\r
137	if (PyErr_ExceptionMatches(PyExc_StopIteration)\r
138	\|\| PyErr_ExceptionMatches(PyExc_GeneratorExit))\r
139	{\r
140	PyErr_Clear(); /* ignore these errors */\r
141	Py_INCREF(Py_None);\r
142	return Py_None;\r
143	}\r
144	return NULL;\r
145	}\r
146	\r
147	static void\r
148	gen_del(PyObject *self)\r
149	{\r
150	PyObject *res;\r
151	PyObject error_type, error_value, *error_traceback;\r
152	PyGenObject gen = (PyGenObject )self;\r
153	\r
154	if (gen->gi_frame == NULL \|\| gen->gi_frame->f_stacktop == NULL)\r
155	/* Generator isn't paused, so no need to close */\r
156	return;\r
157	\r
158	/* Temporarily resurrect the object. */\r
159	assert(self->ob_refcnt == 0);\r
160	self->ob_refcnt = 1;\r
161	\r
162	/* Save the current exception, if any. */\r
163	PyErr_Fetch(&error_type, &error_value, &error_traceback);\r
164	\r
165	res = gen_close(gen, NULL);\r
166	\r
167	if (res == NULL)\r
168	PyErr_WriteUnraisable(self);\r
169	else\r
170	Py_DECREF(res);\r
171	\r
172	/* Restore the saved exception. */\r
173	PyErr_Restore(error_type, error_value, error_traceback);\r
174	\r
175	/* Undo the temporary resurrection; can't use DECREF here, it would\r
176	* cause a recursive call.\r
177	*/\r
178	assert(self->ob_refcnt > 0);\r
179	if (--self->ob_refcnt == 0)\r
180	return; /* this is the normal path out */\r
181	\r
182	/* close() resurrected it! Make it look like the original Py_DECREF\r
183	* never happened.\r
184	*/\r
185	{\r
186	Py_ssize_t refcnt = self->ob_refcnt;\r
187	_Py_NewReference(self);\r
188	self->ob_refcnt = refcnt;\r
189	}\r
190	assert(PyType_IS_GC(self->ob_type) &&\r
191	_Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED);\r
192	\r
193	/* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so\r
194	* we need to undo that. */\r
195	_Py_DEC_REFTOTAL;\r
196	/* If Py_TRACE_REFS, _Py_NewReference re-added self to the object\r
197	* chain, so no more to do there.\r
198	* If COUNT_ALLOCS, the original decref bumped tp_frees, and\r
199	* _Py_NewReference bumped tp_allocs: both of those need to be\r
200	* undone.\r
201	*/\r
202	#ifdef COUNT_ALLOCS\r
203	--self->ob_type->tp_frees;\r
204	--self->ob_type->tp_allocs;\r
205	#endif\r
206	}\r
207	\r
208	\r
209	\r
210	PyDoc_STRVAR(throw_doc,\r
211	"throw(typ[,val[,tb]]) -> raise exception in generator,\n\\r
212	return next yielded value or raise StopIteration.");\r
213	\r
214	static PyObject *\r
215	gen_throw(PyGenObject gen, PyObject args)\r
216	{\r
217	PyObject *typ;\r
218	PyObject *tb = NULL;\r
219	PyObject *val = NULL;\r
220	\r
221	if (!PyArg_UnpackTuple(args, "throw", 1, 3, &typ, &val, &tb))\r
222	return NULL;\r
223	\r
224	/* First, check the traceback argument, replacing None with\r
225	NULL. */\r
226	if (tb == Py_None)\r
227	tb = NULL;\r
228	else if (tb != NULL && !PyTraceBack_Check(tb)) {\r
229	PyErr_SetString(PyExc_TypeError,\r
230	"throw() third argument must be a traceback object");\r
231	return NULL;\r
232	}\r
233	\r
234	Py_INCREF(typ);\r
235	Py_XINCREF(val);\r
236	Py_XINCREF(tb);\r
237	\r
238	if (PyExceptionClass_Check(typ)) {\r
239	PyErr_NormalizeException(&typ, &val, &tb);\r
240	}\r
241	\r
242	else if (PyExceptionInstance_Check(typ)) {\r
243	/* Raising an instance. The value should be a dummy. */\r
244	if (val && val != Py_None) {\r
245	PyErr_SetString(PyExc_TypeError,\r
246	"instance exception may not have a separate value");\r
247	goto failed_throw;\r
248	}\r
249	else {\r
250	/* Normalize to raise <class>, <instance> */\r
251	Py_XDECREF(val);\r
252	val = typ;\r
253	typ = PyExceptionInstance_Class(typ);\r
254	Py_INCREF(typ);\r
255	}\r
256	}\r
257	else {\r
258	/* Not something you can raise. throw() fails. */\r
259	PyErr_Format(PyExc_TypeError,\r
260	"exceptions must be classes, or instances, not %s",\r
261	typ->ob_type->tp_name);\r
262	goto failed_throw;\r
263	}\r
264	\r
265	PyErr_Restore(typ, val, tb);\r
266	return gen_send_ex(gen, Py_None, 1);\r
267	\r
268	failed_throw:\r
269	/* Didn't use our arguments, so restore their original refcounts */\r
270	Py_DECREF(typ);\r
271	Py_XDECREF(val);\r
272	Py_XDECREF(tb);\r
273	return NULL;\r
274	}\r
275	\r
276	\r
277	static PyObject *\r
278	gen_iternext(PyGenObject *gen)\r
279	{\r
280	return gen_send_ex(gen, NULL, 0);\r
281	}\r
282	\r
283	\r
284	static PyObject *\r
285	gen_repr(PyGenObject *gen)\r
286	{\r
287	char *code_name;\r
288	code_name = PyString_AsString(((PyCodeObject *)gen->gi_code)->co_name);\r
289	if (code_name == NULL)\r
290	return NULL;\r
291	return PyString_FromFormat("<generator object %.200s at %p>",\r
292	code_name, gen);\r
293	}\r
294	\r
295	\r
296	static PyObject *\r
297	gen_get_name(PyGenObject *gen)\r
298	{\r
299	PyObject name = ((PyCodeObject )gen->gi_code)->co_name;\r
300	Py_INCREF(name);\r
301	return name;\r
302	}\r
303	\r
304	\r
305	PyDoc_STRVAR(gen__name__doc__,\r
306	"Return the name of the generator's associated code object.");\r
307	\r
308	static PyGetSetDef gen_getsetlist[] = {\r
309	{"__name__", (getter)gen_get_name, NULL, gen__name__doc__},\r
310	{NULL}\r
311	};\r
312	\r
313	\r
314	static PyMemberDef gen_memberlist[] = {\r
315	{"gi_frame", T_OBJECT, offsetof(PyGenObject, gi_frame), RO},\r
316	{"gi_running", T_INT, offsetof(PyGenObject, gi_running), RO},\r
317	{"gi_code", T_OBJECT, offsetof(PyGenObject, gi_code), RO},\r
318	{NULL} /* Sentinel */\r
319	};\r
320	\r
321	static PyMethodDef gen_methods[] = {\r
322	{"send",(PyCFunction)gen_send, METH_O, send_doc},\r
323	{"throw",(PyCFunction)gen_throw, METH_VARARGS, throw_doc},\r
324	{"close",(PyCFunction)gen_close, METH_NOARGS, close_doc},\r
325	{NULL, NULL} /* Sentinel */\r
326	};\r
327	\r
328	PyTypeObject PyGen_Type = {\r
329	PyVarObject_HEAD_INIT(&PyType_Type, 0)\r
330	"generator", /* tp_name */\r
331	sizeof(PyGenObject), /* tp_basicsize */\r
332	0, /* tp_itemsize */\r
333	/* methods */\r
334	(destructor)gen_dealloc, /* tp_dealloc */\r
335	0, /* tp_print */\r
336	0, /* tp_getattr */\r
337	0, /* tp_setattr */\r
338	0, /* tp_compare */\r
339	(reprfunc)gen_repr, /* tp_repr */\r
340	0, /* tp_as_number */\r
341	0, /* tp_as_sequence */\r
342	0, /* tp_as_mapping */\r
343	0, /* tp_hash */\r
344	0, /* tp_call */\r
345	0, /* tp_str */\r
346	PyObject_GenericGetAttr, /* tp_getattro */\r
347	0, /* tp_setattro */\r
348	0, /* tp_as_buffer */\r
349	Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_HAVE_GC,/* tp_flags */\r
350	0, /* tp_doc */\r
351	(traverseproc)gen_traverse, /* tp_traverse */\r
352	0, /* tp_clear */\r
353	0, /* tp_richcompare */\r
354	offsetof(PyGenObject, gi_weakreflist), /* tp_weaklistoffset */\r
355	PyObject_SelfIter, /* tp_iter */\r
356	(iternextfunc)gen_iternext, /* tp_iternext */\r
357	gen_methods, /* tp_methods */\r
358	gen_memberlist, /* tp_members */\r
359	gen_getsetlist, /* tp_getset */\r
360	0, /* tp_base */\r
361	0, /* tp_dict */\r
362	\r
363	0, /* tp_descr_get */\r
364	0, /* tp_descr_set */\r
365	0, /* tp_dictoffset */\r
366	0, /* tp_init */\r
367	0, /* tp_alloc */\r
368	0, /* tp_new */\r
369	0, /* tp_free */\r
370	0, /* tp_is_gc */\r
371	0, /* tp_bases */\r
372	0, /* tp_mro */\r
373	0, /* tp_cache */\r
374	0, /* tp_subclasses */\r
375	0, /* tp_weaklist */\r
376	gen_del, /* tp_del */\r
377	};\r
378	\r
379	PyObject *\r
380	PyGen_New(PyFrameObject *f)\r
381	{\r
382	PyGenObject *gen = PyObject_GC_New(PyGenObject, &PyGen_Type);\r
383	if (gen == NULL) {\r
384	Py_DECREF(f);\r
385	return NULL;\r
386	}\r
387	gen->gi_frame = f;\r
388	Py_INCREF(f->f_code);\r
389	gen->gi_code = (PyObject *)(f->f_code);\r
390	gen->gi_running = 0;\r
391	gen->gi_weakreflist = NULL;\r
392	_PyObject_GC_TRACK(gen);\r
393	return (PyObject *)gen;\r
394	}\r
395	\r
396	int\r
397	PyGen_NeedsFinalizing(PyGenObject *gen)\r
398	{\r
399	int i;\r
400	PyFrameObject *f = gen->gi_frame;\r
401	\r
402	if (f == NULL \|\| f->f_stacktop == NULL \|\| f->f_iblock <= 0)\r
403	return 0; /* no frame or empty blockstack == no finalization */\r
404	\r
405	/* Any block type besides a loop requires cleanup. */\r
406	i = f->f_iblock;\r
407	while (--i >= 0) {\r
408	if (f->f_blockstack[i].b_type != SETUP_LOOP)\r
409	return 1;\r
410	}\r
411	\r
412	/* No blocks except loops, it's safe to skip finalization. */\r
413	return 0;\r
414	}\r