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