|
1 #include "Python.h" |
|
2 #include "structmember.h" |
|
3 |
|
4 |
|
5 #define GET_WEAKREFS_LISTPTR(o) \ |
|
6 ((PyWeakReference **) PyObject_GET_WEAKREFS_LISTPTR(o)) |
|
7 |
|
8 |
|
9 Py_ssize_t |
|
10 _PyWeakref_GetWeakrefCount(PyWeakReference *head) |
|
11 { |
|
12 Py_ssize_t count = 0; |
|
13 |
|
14 while (head != NULL) { |
|
15 ++count; |
|
16 head = head->wr_next; |
|
17 } |
|
18 return count; |
|
19 } |
|
20 |
|
21 |
|
22 static void |
|
23 init_weakref(PyWeakReference *self, PyObject *ob, PyObject *callback) |
|
24 { |
|
25 self->hash = -1; |
|
26 self->wr_object = ob; |
|
27 Py_XINCREF(callback); |
|
28 self->wr_callback = callback; |
|
29 } |
|
30 |
|
31 static PyWeakReference * |
|
32 new_weakref(PyObject *ob, PyObject *callback) |
|
33 { |
|
34 PyWeakReference *result; |
|
35 |
|
36 result = PyObject_GC_New(PyWeakReference, &_PyWeakref_RefType); |
|
37 if (result) { |
|
38 init_weakref(result, ob, callback); |
|
39 PyObject_GC_Track(result); |
|
40 } |
|
41 return result; |
|
42 } |
|
43 |
|
44 |
|
45 /* This function clears the passed-in reference and removes it from the |
|
46 * list of weak references for the referent. This is the only code that |
|
47 * removes an item from the doubly-linked list of weak references for an |
|
48 * object; it is also responsible for clearing the callback slot. |
|
49 */ |
|
50 static void |
|
51 clear_weakref(PyWeakReference *self) |
|
52 { |
|
53 PyObject *callback = self->wr_callback; |
|
54 |
|
55 if (PyWeakref_GET_OBJECT(self) != Py_None) { |
|
56 PyWeakReference **list = GET_WEAKREFS_LISTPTR( |
|
57 PyWeakref_GET_OBJECT(self)); |
|
58 |
|
59 if (*list == self) |
|
60 /* If 'self' is the end of the list (and thus self->wr_next == NULL) |
|
61 then the weakref list itself (and thus the value of *list) will |
|
62 end up being set to NULL. */ |
|
63 *list = self->wr_next; |
|
64 self->wr_object = Py_None; |
|
65 if (self->wr_prev != NULL) |
|
66 self->wr_prev->wr_next = self->wr_next; |
|
67 if (self->wr_next != NULL) |
|
68 self->wr_next->wr_prev = self->wr_prev; |
|
69 self->wr_prev = NULL; |
|
70 self->wr_next = NULL; |
|
71 } |
|
72 if (callback != NULL) { |
|
73 Py_DECREF(callback); |
|
74 self->wr_callback = NULL; |
|
75 } |
|
76 } |
|
77 |
|
78 /* Cyclic gc uses this to *just* clear the passed-in reference, leaving |
|
79 * the callback intact and uncalled. It must be possible to call self's |
|
80 * tp_dealloc() after calling this, so self has to be left in a sane enough |
|
81 * state for that to work. We expect tp_dealloc to decref the callback |
|
82 * then. The reason for not letting clear_weakref() decref the callback |
|
83 * right now is that if the callback goes away, that may in turn trigger |
|
84 * another callback (if a weak reference to the callback exists) -- running |
|
85 * arbitrary Python code in the middle of gc is a disaster. The convolution |
|
86 * here allows gc to delay triggering such callbacks until the world is in |
|
87 * a sane state again. |
|
88 */ |
|
89 void |
|
90 _PyWeakref_ClearRef(PyWeakReference *self) |
|
91 { |
|
92 PyObject *callback; |
|
93 |
|
94 assert(self != NULL); |
|
95 assert(PyWeakref_Check(self)); |
|
96 /* Preserve and restore the callback around clear_weakref. */ |
|
97 callback = self->wr_callback; |
|
98 self->wr_callback = NULL; |
|
99 clear_weakref(self); |
|
100 self->wr_callback = callback; |
|
101 } |
|
102 |
|
103 static void |
|
104 weakref_dealloc(PyObject *self) |
|
105 { |
|
106 PyObject_GC_UnTrack(self); |
|
107 clear_weakref((PyWeakReference *) self); |
|
108 Py_TYPE(self)->tp_free(self); |
|
109 } |
|
110 |
|
111 |
|
112 static int |
|
113 gc_traverse(PyWeakReference *self, visitproc visit, void *arg) |
|
114 { |
|
115 Py_VISIT(self->wr_callback); |
|
116 return 0; |
|
117 } |
|
118 |
|
119 |
|
120 static int |
|
121 gc_clear(PyWeakReference *self) |
|
122 { |
|
123 clear_weakref(self); |
|
124 return 0; |
|
125 } |
|
126 |
|
127 |
|
128 static PyObject * |
|
129 weakref_call(PyWeakReference *self, PyObject *args, PyObject *kw) |
|
130 { |
|
131 static char *kwlist[] = {NULL}; |
|
132 |
|
133 if (PyArg_ParseTupleAndKeywords(args, kw, ":__call__", kwlist)) { |
|
134 PyObject *object = PyWeakref_GET_OBJECT(self); |
|
135 Py_INCREF(object); |
|
136 return (object); |
|
137 } |
|
138 return NULL; |
|
139 } |
|
140 |
|
141 |
|
142 static long |
|
143 weakref_hash(PyWeakReference *self) |
|
144 { |
|
145 if (self->hash != -1) |
|
146 return self->hash; |
|
147 if (PyWeakref_GET_OBJECT(self) == Py_None) { |
|
148 PyErr_SetString(PyExc_TypeError, "weak object has gone away"); |
|
149 return -1; |
|
150 } |
|
151 self->hash = PyObject_Hash(PyWeakref_GET_OBJECT(self)); |
|
152 return self->hash; |
|
153 } |
|
154 |
|
155 |
|
156 static PyObject * |
|
157 weakref_repr(PyWeakReference *self) |
|
158 { |
|
159 char buffer[256]; |
|
160 if (PyWeakref_GET_OBJECT(self) == Py_None) { |
|
161 PyOS_snprintf(buffer, sizeof(buffer), "<weakref at %p; dead>", self); |
|
162 } |
|
163 else { |
|
164 char *name = NULL; |
|
165 PyObject *nameobj = PyObject_GetAttrString(PyWeakref_GET_OBJECT(self), |
|
166 "__name__"); |
|
167 if (nameobj == NULL) |
|
168 PyErr_Clear(); |
|
169 else if (PyString_Check(nameobj)) |
|
170 name = PyString_AS_STRING(nameobj); |
|
171 PyOS_snprintf(buffer, sizeof(buffer), |
|
172 name ? "<weakref at %p; to '%.50s' at %p (%s)>" |
|
173 : "<weakref at %p; to '%.50s' at %p>", |
|
174 self, |
|
175 Py_TYPE(PyWeakref_GET_OBJECT(self))->tp_name, |
|
176 PyWeakref_GET_OBJECT(self), |
|
177 name); |
|
178 Py_XDECREF(nameobj); |
|
179 } |
|
180 return PyString_FromString(buffer); |
|
181 } |
|
182 |
|
183 /* Weak references only support equality, not ordering. Two weak references |
|
184 are equal if the underlying objects are equal. If the underlying object has |
|
185 gone away, they are equal if they are identical. */ |
|
186 |
|
187 static PyObject * |
|
188 weakref_richcompare(PyWeakReference* self, PyWeakReference* other, int op) |
|
189 { |
|
190 if (op != Py_EQ || self->ob_type != other->ob_type) { |
|
191 Py_INCREF(Py_NotImplemented); |
|
192 return Py_NotImplemented; |
|
193 } |
|
194 if (PyWeakref_GET_OBJECT(self) == Py_None |
|
195 || PyWeakref_GET_OBJECT(other) == Py_None) { |
|
196 PyObject *res = self==other ? Py_True : Py_False; |
|
197 Py_INCREF(res); |
|
198 return res; |
|
199 } |
|
200 return PyObject_RichCompare(PyWeakref_GET_OBJECT(self), |
|
201 PyWeakref_GET_OBJECT(other), op); |
|
202 } |
|
203 |
|
204 /* Given the head of an object's list of weak references, extract the |
|
205 * two callback-less refs (ref and proxy). Used to determine if the |
|
206 * shared references exist and to determine the back link for newly |
|
207 * inserted references. |
|
208 */ |
|
209 static void |
|
210 get_basic_refs(PyWeakReference *head, |
|
211 PyWeakReference **refp, PyWeakReference **proxyp) |
|
212 { |
|
213 *refp = NULL; |
|
214 *proxyp = NULL; |
|
215 |
|
216 if (head != NULL && head->wr_callback == NULL) { |
|
217 /* We need to be careful that the "basic refs" aren't |
|
218 subclasses of the main types. That complicates this a |
|
219 little. */ |
|
220 if (PyWeakref_CheckRefExact(head)) { |
|
221 *refp = head; |
|
222 head = head->wr_next; |
|
223 } |
|
224 if (head != NULL |
|
225 && head->wr_callback == NULL |
|
226 && PyWeakref_CheckProxy(head)) { |
|
227 *proxyp = head; |
|
228 /* head = head->wr_next; */ |
|
229 } |
|
230 } |
|
231 } |
|
232 |
|
233 /* Insert 'newref' in the list after 'prev'. Both must be non-NULL. */ |
|
234 static void |
|
235 insert_after(PyWeakReference *newref, PyWeakReference *prev) |
|
236 { |
|
237 newref->wr_prev = prev; |
|
238 newref->wr_next = prev->wr_next; |
|
239 if (prev->wr_next != NULL) |
|
240 prev->wr_next->wr_prev = newref; |
|
241 prev->wr_next = newref; |
|
242 } |
|
243 |
|
244 /* Insert 'newref' at the head of the list; 'list' points to the variable |
|
245 * that stores the head. |
|
246 */ |
|
247 static void |
|
248 insert_head(PyWeakReference *newref, PyWeakReference **list) |
|
249 { |
|
250 PyWeakReference *next = *list; |
|
251 |
|
252 newref->wr_prev = NULL; |
|
253 newref->wr_next = next; |
|
254 if (next != NULL) |
|
255 next->wr_prev = newref; |
|
256 *list = newref; |
|
257 } |
|
258 |
|
259 static int |
|
260 parse_weakref_init_args(char *funcname, PyObject *args, PyObject *kwargs, |
|
261 PyObject **obp, PyObject **callbackp) |
|
262 { |
|
263 /* XXX Should check that kwargs == NULL or is empty. */ |
|
264 return PyArg_UnpackTuple(args, funcname, 1, 2, obp, callbackp); |
|
265 } |
|
266 |
|
267 static PyObject * |
|
268 weakref___new__(PyTypeObject *type, PyObject *args, PyObject *kwargs) |
|
269 { |
|
270 PyWeakReference *self = NULL; |
|
271 PyObject *ob, *callback = NULL; |
|
272 |
|
273 if (parse_weakref_init_args("__new__", args, kwargs, &ob, &callback)) { |
|
274 PyWeakReference *ref, *proxy; |
|
275 PyWeakReference **list; |
|
276 |
|
277 if (!PyType_SUPPORTS_WEAKREFS(Py_TYPE(ob))) { |
|
278 PyErr_Format(PyExc_TypeError, |
|
279 "cannot create weak reference to '%s' object", |
|
280 Py_TYPE(ob)->tp_name); |
|
281 return NULL; |
|
282 } |
|
283 if (callback == Py_None) |
|
284 callback = NULL; |
|
285 list = GET_WEAKREFS_LISTPTR(ob); |
|
286 get_basic_refs(*list, &ref, &proxy); |
|
287 if (callback == NULL && type == &_PyWeakref_RefType) { |
|
288 if (ref != NULL) { |
|
289 /* We can re-use an existing reference. */ |
|
290 Py_INCREF(ref); |
|
291 return (PyObject *)ref; |
|
292 } |
|
293 } |
|
294 /* We have to create a new reference. */ |
|
295 /* Note: the tp_alloc() can trigger cyclic GC, so the weakref |
|
296 list on ob can be mutated. This means that the ref and |
|
297 proxy pointers we got back earlier may have been collected, |
|
298 so we need to compute these values again before we use |
|
299 them. */ |
|
300 self = (PyWeakReference *) (type->tp_alloc(type, 0)); |
|
301 if (self != NULL) { |
|
302 init_weakref(self, ob, callback); |
|
303 if (callback == NULL && type == &_PyWeakref_RefType) { |
|
304 insert_head(self, list); |
|
305 } |
|
306 else { |
|
307 PyWeakReference *prev; |
|
308 |
|
309 get_basic_refs(*list, &ref, &proxy); |
|
310 prev = (proxy == NULL) ? ref : proxy; |
|
311 if (prev == NULL) |
|
312 insert_head(self, list); |
|
313 else |
|
314 insert_after(self, prev); |
|
315 } |
|
316 } |
|
317 } |
|
318 return (PyObject *)self; |
|
319 } |
|
320 |
|
321 static int |
|
322 weakref___init__(PyObject *self, PyObject *args, PyObject *kwargs) |
|
323 { |
|
324 PyObject *tmp; |
|
325 |
|
326 if (parse_weakref_init_args("__init__", args, kwargs, &tmp, &tmp)) |
|
327 return 0; |
|
328 else |
|
329 return -1; |
|
330 } |
|
331 |
|
332 |
|
333 PyTypeObject |
|
334 _PyWeakref_RefType = { |
|
335 PyVarObject_HEAD_INIT(&PyType_Type, 0) |
|
336 "weakref", |
|
337 sizeof(PyWeakReference), |
|
338 0, |
|
339 weakref_dealloc, /*tp_dealloc*/ |
|
340 0, /*tp_print*/ |
|
341 0, /*tp_getattr*/ |
|
342 0, /*tp_setattr*/ |
|
343 0, /*tp_compare*/ |
|
344 (reprfunc)weakref_repr, /*tp_repr*/ |
|
345 0, /*tp_as_number*/ |
|
346 0, /*tp_as_sequence*/ |
|
347 0, /*tp_as_mapping*/ |
|
348 (hashfunc)weakref_hash, /*tp_hash*/ |
|
349 (ternaryfunc)weakref_call, /*tp_call*/ |
|
350 0, /*tp_str*/ |
|
351 0, /*tp_getattro*/ |
|
352 0, /*tp_setattro*/ |
|
353 0, /*tp_as_buffer*/ |
|
354 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_RICHCOMPARE |
|
355 | Py_TPFLAGS_BASETYPE, /*tp_flags*/ |
|
356 0, /*tp_doc*/ |
|
357 (traverseproc)gc_traverse, /*tp_traverse*/ |
|
358 (inquiry)gc_clear, /*tp_clear*/ |
|
359 (richcmpfunc)weakref_richcompare, /*tp_richcompare*/ |
|
360 0, /*tp_weaklistoffset*/ |
|
361 0, /*tp_iter*/ |
|
362 0, /*tp_iternext*/ |
|
363 0, /*tp_methods*/ |
|
364 0, /*tp_members*/ |
|
365 0, /*tp_getset*/ |
|
366 0, /*tp_base*/ |
|
367 0, /*tp_dict*/ |
|
368 0, /*tp_descr_get*/ |
|
369 0, /*tp_descr_set*/ |
|
370 0, /*tp_dictoffset*/ |
|
371 weakref___init__, /*tp_init*/ |
|
372 PyType_GenericAlloc, /*tp_alloc*/ |
|
373 weakref___new__, /*tp_new*/ |
|
374 PyObject_GC_Del, /*tp_free*/ |
|
375 }; |
|
376 |
|
377 |
|
378 static int |
|
379 proxy_checkref(PyWeakReference *proxy) |
|
380 { |
|
381 if (PyWeakref_GET_OBJECT(proxy) == Py_None) { |
|
382 PyErr_SetString(PyExc_ReferenceError, |
|
383 "weakly-referenced object no longer exists"); |
|
384 return 0; |
|
385 } |
|
386 return 1; |
|
387 } |
|
388 |
|
389 |
|
390 /* If a parameter is a proxy, check that it is still "live" and wrap it, |
|
391 * replacing the original value with the raw object. Raises ReferenceError |
|
392 * if the param is a dead proxy. |
|
393 */ |
|
394 #define UNWRAP(o) \ |
|
395 if (PyWeakref_CheckProxy(o)) { \ |
|
396 if (!proxy_checkref((PyWeakReference *)o)) \ |
|
397 return NULL; \ |
|
398 o = PyWeakref_GET_OBJECT(o); \ |
|
399 } |
|
400 |
|
401 #define UNWRAP_I(o) \ |
|
402 if (PyWeakref_CheckProxy(o)) { \ |
|
403 if (!proxy_checkref((PyWeakReference *)o)) \ |
|
404 return -1; \ |
|
405 o = PyWeakref_GET_OBJECT(o); \ |
|
406 } |
|
407 |
|
408 #define WRAP_UNARY(method, generic) \ |
|
409 static PyObject * \ |
|
410 method(PyObject *proxy) { \ |
|
411 UNWRAP(proxy); \ |
|
412 return generic(proxy); \ |
|
413 } |
|
414 |
|
415 #define WRAP_BINARY(method, generic) \ |
|
416 static PyObject * \ |
|
417 method(PyObject *x, PyObject *y) { \ |
|
418 UNWRAP(x); \ |
|
419 UNWRAP(y); \ |
|
420 return generic(x, y); \ |
|
421 } |
|
422 |
|
423 /* Note that the third arg needs to be checked for NULL since the tp_call |
|
424 * slot can receive NULL for this arg. |
|
425 */ |
|
426 #define WRAP_TERNARY(method, generic) \ |
|
427 static PyObject * \ |
|
428 method(PyObject *proxy, PyObject *v, PyObject *w) { \ |
|
429 UNWRAP(proxy); \ |
|
430 UNWRAP(v); \ |
|
431 if (w != NULL) \ |
|
432 UNWRAP(w); \ |
|
433 return generic(proxy, v, w); \ |
|
434 } |
|
435 |
|
436 |
|
437 /* direct slots */ |
|
438 |
|
439 WRAP_BINARY(proxy_getattr, PyObject_GetAttr) |
|
440 WRAP_UNARY(proxy_str, PyObject_Str) |
|
441 WRAP_TERNARY(proxy_call, PyEval_CallObjectWithKeywords) |
|
442 |
|
443 static PyObject * |
|
444 proxy_repr(PyWeakReference *proxy) |
|
445 { |
|
446 char buf[160]; |
|
447 PyOS_snprintf(buf, sizeof(buf), |
|
448 "<weakproxy at %p to %.100s at %p>", proxy, |
|
449 Py_TYPE(PyWeakref_GET_OBJECT(proxy))->tp_name, |
|
450 PyWeakref_GET_OBJECT(proxy)); |
|
451 return PyString_FromString(buf); |
|
452 } |
|
453 |
|
454 |
|
455 static int |
|
456 proxy_setattr(PyWeakReference *proxy, PyObject *name, PyObject *value) |
|
457 { |
|
458 if (!proxy_checkref(proxy)) |
|
459 return -1; |
|
460 return PyObject_SetAttr(PyWeakref_GET_OBJECT(proxy), name, value); |
|
461 } |
|
462 |
|
463 static int |
|
464 proxy_compare(PyObject *proxy, PyObject *v) |
|
465 { |
|
466 UNWRAP_I(proxy); |
|
467 UNWRAP_I(v); |
|
468 return PyObject_Compare(proxy, v); |
|
469 } |
|
470 |
|
471 /* number slots */ |
|
472 WRAP_BINARY(proxy_add, PyNumber_Add) |
|
473 WRAP_BINARY(proxy_sub, PyNumber_Subtract) |
|
474 WRAP_BINARY(proxy_mul, PyNumber_Multiply) |
|
475 WRAP_BINARY(proxy_div, PyNumber_Divide) |
|
476 WRAP_BINARY(proxy_floor_div, PyNumber_FloorDivide) |
|
477 WRAP_BINARY(proxy_true_div, PyNumber_TrueDivide) |
|
478 WRAP_BINARY(proxy_mod, PyNumber_Remainder) |
|
479 WRAP_BINARY(proxy_divmod, PyNumber_Divmod) |
|
480 WRAP_TERNARY(proxy_pow, PyNumber_Power) |
|
481 WRAP_UNARY(proxy_neg, PyNumber_Negative) |
|
482 WRAP_UNARY(proxy_pos, PyNumber_Positive) |
|
483 WRAP_UNARY(proxy_abs, PyNumber_Absolute) |
|
484 WRAP_UNARY(proxy_invert, PyNumber_Invert) |
|
485 WRAP_BINARY(proxy_lshift, PyNumber_Lshift) |
|
486 WRAP_BINARY(proxy_rshift, PyNumber_Rshift) |
|
487 WRAP_BINARY(proxy_and, PyNumber_And) |
|
488 WRAP_BINARY(proxy_xor, PyNumber_Xor) |
|
489 WRAP_BINARY(proxy_or, PyNumber_Or) |
|
490 WRAP_UNARY(proxy_int, PyNumber_Int) |
|
491 WRAP_UNARY(proxy_long, PyNumber_Long) |
|
492 WRAP_UNARY(proxy_float, PyNumber_Float) |
|
493 WRAP_BINARY(proxy_iadd, PyNumber_InPlaceAdd) |
|
494 WRAP_BINARY(proxy_isub, PyNumber_InPlaceSubtract) |
|
495 WRAP_BINARY(proxy_imul, PyNumber_InPlaceMultiply) |
|
496 WRAP_BINARY(proxy_idiv, PyNumber_InPlaceDivide) |
|
497 WRAP_BINARY(proxy_ifloor_div, PyNumber_InPlaceFloorDivide) |
|
498 WRAP_BINARY(proxy_itrue_div, PyNumber_InPlaceTrueDivide) |
|
499 WRAP_BINARY(proxy_imod, PyNumber_InPlaceRemainder) |
|
500 WRAP_TERNARY(proxy_ipow, PyNumber_InPlacePower) |
|
501 WRAP_BINARY(proxy_ilshift, PyNumber_InPlaceLshift) |
|
502 WRAP_BINARY(proxy_irshift, PyNumber_InPlaceRshift) |
|
503 WRAP_BINARY(proxy_iand, PyNumber_InPlaceAnd) |
|
504 WRAP_BINARY(proxy_ixor, PyNumber_InPlaceXor) |
|
505 WRAP_BINARY(proxy_ior, PyNumber_InPlaceOr) |
|
506 WRAP_UNARY(proxy_index, PyNumber_Index) |
|
507 |
|
508 static int |
|
509 proxy_nonzero(PyWeakReference *proxy) |
|
510 { |
|
511 PyObject *o = PyWeakref_GET_OBJECT(proxy); |
|
512 if (!proxy_checkref(proxy)) |
|
513 return -1; |
|
514 return PyObject_IsTrue(o); |
|
515 } |
|
516 |
|
517 static void |
|
518 proxy_dealloc(PyWeakReference *self) |
|
519 { |
|
520 if (self->wr_callback != NULL) |
|
521 PyObject_GC_UnTrack((PyObject *)self); |
|
522 clear_weakref(self); |
|
523 PyObject_GC_Del(self); |
|
524 } |
|
525 |
|
526 /* sequence slots */ |
|
527 |
|
528 static PyObject * |
|
529 proxy_slice(PyWeakReference *proxy, Py_ssize_t i, Py_ssize_t j) |
|
530 { |
|
531 if (!proxy_checkref(proxy)) |
|
532 return NULL; |
|
533 return PySequence_GetSlice(PyWeakref_GET_OBJECT(proxy), i, j); |
|
534 } |
|
535 |
|
536 static int |
|
537 proxy_ass_slice(PyWeakReference *proxy, Py_ssize_t i, Py_ssize_t j, PyObject *value) |
|
538 { |
|
539 if (!proxy_checkref(proxy)) |
|
540 return -1; |
|
541 return PySequence_SetSlice(PyWeakref_GET_OBJECT(proxy), i, j, value); |
|
542 } |
|
543 |
|
544 static int |
|
545 proxy_contains(PyWeakReference *proxy, PyObject *value) |
|
546 { |
|
547 if (!proxy_checkref(proxy)) |
|
548 return -1; |
|
549 return PySequence_Contains(PyWeakref_GET_OBJECT(proxy), value); |
|
550 } |
|
551 |
|
552 |
|
553 /* mapping slots */ |
|
554 |
|
555 static Py_ssize_t |
|
556 proxy_length(PyWeakReference *proxy) |
|
557 { |
|
558 if (!proxy_checkref(proxy)) |
|
559 return -1; |
|
560 return PyObject_Length(PyWeakref_GET_OBJECT(proxy)); |
|
561 } |
|
562 |
|
563 WRAP_BINARY(proxy_getitem, PyObject_GetItem) |
|
564 |
|
565 static int |
|
566 proxy_setitem(PyWeakReference *proxy, PyObject *key, PyObject *value) |
|
567 { |
|
568 if (!proxy_checkref(proxy)) |
|
569 return -1; |
|
570 |
|
571 if (value == NULL) |
|
572 return PyObject_DelItem(PyWeakref_GET_OBJECT(proxy), key); |
|
573 else |
|
574 return PyObject_SetItem(PyWeakref_GET_OBJECT(proxy), key, value); |
|
575 } |
|
576 |
|
577 /* iterator slots */ |
|
578 |
|
579 static PyObject * |
|
580 proxy_iter(PyWeakReference *proxy) |
|
581 { |
|
582 if (!proxy_checkref(proxy)) |
|
583 return NULL; |
|
584 return PyObject_GetIter(PyWeakref_GET_OBJECT(proxy)); |
|
585 } |
|
586 |
|
587 static PyObject * |
|
588 proxy_iternext(PyWeakReference *proxy) |
|
589 { |
|
590 if (!proxy_checkref(proxy)) |
|
591 return NULL; |
|
592 return PyIter_Next(PyWeakref_GET_OBJECT(proxy)); |
|
593 } |
|
594 |
|
595 |
|
596 static PyNumberMethods proxy_as_number = { |
|
597 proxy_add, /*nb_add*/ |
|
598 proxy_sub, /*nb_subtract*/ |
|
599 proxy_mul, /*nb_multiply*/ |
|
600 proxy_div, /*nb_divide*/ |
|
601 proxy_mod, /*nb_remainder*/ |
|
602 proxy_divmod, /*nb_divmod*/ |
|
603 proxy_pow, /*nb_power*/ |
|
604 proxy_neg, /*nb_negative*/ |
|
605 proxy_pos, /*nb_positive*/ |
|
606 proxy_abs, /*nb_absolute*/ |
|
607 (inquiry)proxy_nonzero, /*nb_nonzero*/ |
|
608 proxy_invert, /*nb_invert*/ |
|
609 proxy_lshift, /*nb_lshift*/ |
|
610 proxy_rshift, /*nb_rshift*/ |
|
611 proxy_and, /*nb_and*/ |
|
612 proxy_xor, /*nb_xor*/ |
|
613 proxy_or, /*nb_or*/ |
|
614 0, /*nb_coerce*/ |
|
615 proxy_int, /*nb_int*/ |
|
616 proxy_long, /*nb_long*/ |
|
617 proxy_float, /*nb_float*/ |
|
618 0, /*nb_oct*/ |
|
619 0, /*nb_hex*/ |
|
620 proxy_iadd, /*nb_inplace_add*/ |
|
621 proxy_isub, /*nb_inplace_subtract*/ |
|
622 proxy_imul, /*nb_inplace_multiply*/ |
|
623 proxy_idiv, /*nb_inplace_divide*/ |
|
624 proxy_imod, /*nb_inplace_remainder*/ |
|
625 proxy_ipow, /*nb_inplace_power*/ |
|
626 proxy_ilshift, /*nb_inplace_lshift*/ |
|
627 proxy_irshift, /*nb_inplace_rshift*/ |
|
628 proxy_iand, /*nb_inplace_and*/ |
|
629 proxy_ixor, /*nb_inplace_xor*/ |
|
630 proxy_ior, /*nb_inplace_or*/ |
|
631 proxy_floor_div, /*nb_floor_divide*/ |
|
632 proxy_true_div, /*nb_true_divide*/ |
|
633 proxy_ifloor_div, /*nb_inplace_floor_divide*/ |
|
634 proxy_itrue_div, /*nb_inplace_true_divide*/ |
|
635 proxy_index, /*nb_index*/ |
|
636 }; |
|
637 |
|
638 static PySequenceMethods proxy_as_sequence = { |
|
639 (lenfunc)proxy_length, /*sq_length*/ |
|
640 0, /*sq_concat*/ |
|
641 0, /*sq_repeat*/ |
|
642 0, /*sq_item*/ |
|
643 (ssizessizeargfunc)proxy_slice, /*sq_slice*/ |
|
644 0, /*sq_ass_item*/ |
|
645 (ssizessizeobjargproc)proxy_ass_slice, /*sq_ass_slice*/ |
|
646 (objobjproc)proxy_contains, /* sq_contains */ |
|
647 }; |
|
648 |
|
649 static PyMappingMethods proxy_as_mapping = { |
|
650 (lenfunc)proxy_length, /*mp_length*/ |
|
651 proxy_getitem, /*mp_subscript*/ |
|
652 (objobjargproc)proxy_setitem, /*mp_ass_subscript*/ |
|
653 }; |
|
654 |
|
655 |
|
656 PyTypeObject |
|
657 _PyWeakref_ProxyType = { |
|
658 PyVarObject_HEAD_INIT(&PyType_Type, 0) |
|
659 "weakproxy", |
|
660 sizeof(PyWeakReference), |
|
661 0, |
|
662 /* methods */ |
|
663 (destructor)proxy_dealloc, /* tp_dealloc */ |
|
664 0, /* tp_print */ |
|
665 0, /* tp_getattr */ |
|
666 0, /* tp_setattr */ |
|
667 proxy_compare, /* tp_compare */ |
|
668 (reprfunc)proxy_repr, /* tp_repr */ |
|
669 &proxy_as_number, /* tp_as_number */ |
|
670 &proxy_as_sequence, /* tp_as_sequence */ |
|
671 &proxy_as_mapping, /* tp_as_mapping */ |
|
672 0, /* tp_hash */ |
|
673 0, /* tp_call */ |
|
674 proxy_str, /* tp_str */ |
|
675 proxy_getattr, /* tp_getattro */ |
|
676 (setattrofunc)proxy_setattr, /* tp_setattro */ |
|
677 0, /* tp_as_buffer */ |
|
678 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
|
679 | Py_TPFLAGS_CHECKTYPES, /* tp_flags */ |
|
680 0, /* tp_doc */ |
|
681 (traverseproc)gc_traverse, /* tp_traverse */ |
|
682 (inquiry)gc_clear, /* tp_clear */ |
|
683 0, /* tp_richcompare */ |
|
684 0, /* tp_weaklistoffset */ |
|
685 (getiterfunc)proxy_iter, /* tp_iter */ |
|
686 (iternextfunc)proxy_iternext, /* tp_iternext */ |
|
687 }; |
|
688 |
|
689 |
|
690 PyTypeObject |
|
691 _PyWeakref_CallableProxyType = { |
|
692 PyVarObject_HEAD_INIT(&PyType_Type, 0) |
|
693 "weakcallableproxy", |
|
694 sizeof(PyWeakReference), |
|
695 0, |
|
696 /* methods */ |
|
697 (destructor)proxy_dealloc, /* tp_dealloc */ |
|
698 0, /* tp_print */ |
|
699 0, /* tp_getattr */ |
|
700 0, /* tp_setattr */ |
|
701 proxy_compare, /* tp_compare */ |
|
702 (unaryfunc)proxy_repr, /* tp_repr */ |
|
703 &proxy_as_number, /* tp_as_number */ |
|
704 &proxy_as_sequence, /* tp_as_sequence */ |
|
705 &proxy_as_mapping, /* tp_as_mapping */ |
|
706 0, /* tp_hash */ |
|
707 proxy_call, /* tp_call */ |
|
708 proxy_str, /* tp_str */ |
|
709 proxy_getattr, /* tp_getattro */ |
|
710 (setattrofunc)proxy_setattr, /* tp_setattro */ |
|
711 0, /* tp_as_buffer */ |
|
712 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
|
713 | Py_TPFLAGS_CHECKTYPES, /* tp_flags */ |
|
714 0, /* tp_doc */ |
|
715 (traverseproc)gc_traverse, /* tp_traverse */ |
|
716 (inquiry)gc_clear, /* tp_clear */ |
|
717 0, /* tp_richcompare */ |
|
718 0, /* tp_weaklistoffset */ |
|
719 (getiterfunc)proxy_iter, /* tp_iter */ |
|
720 (iternextfunc)proxy_iternext, /* tp_iternext */ |
|
721 }; |
|
722 |
|
723 |
|
724 |
|
725 PyObject * |
|
726 PyWeakref_NewRef(PyObject *ob, PyObject *callback) |
|
727 { |
|
728 PyWeakReference *result = NULL; |
|
729 PyWeakReference **list; |
|
730 PyWeakReference *ref, *proxy; |
|
731 |
|
732 if (!PyType_SUPPORTS_WEAKREFS(Py_TYPE(ob))) { |
|
733 PyErr_Format(PyExc_TypeError, |
|
734 "cannot create weak reference to '%s' object", |
|
735 Py_TYPE(ob)->tp_name); |
|
736 return NULL; |
|
737 } |
|
738 list = GET_WEAKREFS_LISTPTR(ob); |
|
739 get_basic_refs(*list, &ref, &proxy); |
|
740 if (callback == Py_None) |
|
741 callback = NULL; |
|
742 if (callback == NULL) |
|
743 /* return existing weak reference if it exists */ |
|
744 result = ref; |
|
745 if (result != NULL) |
|
746 Py_INCREF(result); |
|
747 else { |
|
748 /* Note: new_weakref() can trigger cyclic GC, so the weakref |
|
749 list on ob can be mutated. This means that the ref and |
|
750 proxy pointers we got back earlier may have been collected, |
|
751 so we need to compute these values again before we use |
|
752 them. */ |
|
753 result = new_weakref(ob, callback); |
|
754 if (result != NULL) { |
|
755 get_basic_refs(*list, &ref, &proxy); |
|
756 if (callback == NULL) { |
|
757 if (ref == NULL) |
|
758 insert_head(result, list); |
|
759 else { |
|
760 /* Someone else added a ref without a callback |
|
761 during GC. Return that one instead of this one |
|
762 to avoid violating the invariants of the list |
|
763 of weakrefs for ob. */ |
|
764 Py_DECREF(result); |
|
765 Py_INCREF(ref); |
|
766 result = ref; |
|
767 } |
|
768 } |
|
769 else { |
|
770 PyWeakReference *prev; |
|
771 |
|
772 prev = (proxy == NULL) ? ref : proxy; |
|
773 if (prev == NULL) |
|
774 insert_head(result, list); |
|
775 else |
|
776 insert_after(result, prev); |
|
777 } |
|
778 } |
|
779 } |
|
780 return (PyObject *) result; |
|
781 } |
|
782 |
|
783 |
|
784 PyObject * |
|
785 PyWeakref_NewProxy(PyObject *ob, PyObject *callback) |
|
786 { |
|
787 PyWeakReference *result = NULL; |
|
788 PyWeakReference **list; |
|
789 PyWeakReference *ref, *proxy; |
|
790 |
|
791 if (!PyType_SUPPORTS_WEAKREFS(Py_TYPE(ob))) { |
|
792 PyErr_Format(PyExc_TypeError, |
|
793 "cannot create weak reference to '%s' object", |
|
794 Py_TYPE(ob)->tp_name); |
|
795 return NULL; |
|
796 } |
|
797 list = GET_WEAKREFS_LISTPTR(ob); |
|
798 get_basic_refs(*list, &ref, &proxy); |
|
799 if (callback == Py_None) |
|
800 callback = NULL; |
|
801 if (callback == NULL) |
|
802 /* attempt to return an existing weak reference if it exists */ |
|
803 result = proxy; |
|
804 if (result != NULL) |
|
805 Py_INCREF(result); |
|
806 else { |
|
807 /* Note: new_weakref() can trigger cyclic GC, so the weakref |
|
808 list on ob can be mutated. This means that the ref and |
|
809 proxy pointers we got back earlier may have been collected, |
|
810 so we need to compute these values again before we use |
|
811 them. */ |
|
812 result = new_weakref(ob, callback); |
|
813 if (result != NULL) { |
|
814 PyWeakReference *prev; |
|
815 |
|
816 if (PyCallable_Check(ob)) |
|
817 Py_TYPE(result) = &_PyWeakref_CallableProxyType; |
|
818 else |
|
819 Py_TYPE(result) = &_PyWeakref_ProxyType; |
|
820 get_basic_refs(*list, &ref, &proxy); |
|
821 if (callback == NULL) { |
|
822 if (proxy != NULL) { |
|
823 /* Someone else added a proxy without a callback |
|
824 during GC. Return that one instead of this one |
|
825 to avoid violating the invariants of the list |
|
826 of weakrefs for ob. */ |
|
827 Py_DECREF(result); |
|
828 Py_INCREF(result = proxy); |
|
829 goto skip_insert; |
|
830 } |
|
831 prev = ref; |
|
832 } |
|
833 else |
|
834 prev = (proxy == NULL) ? ref : proxy; |
|
835 |
|
836 if (prev == NULL) |
|
837 insert_head(result, list); |
|
838 else |
|
839 insert_after(result, prev); |
|
840 skip_insert: |
|
841 ; |
|
842 } |
|
843 } |
|
844 return (PyObject *) result; |
|
845 } |
|
846 |
|
847 |
|
848 PyObject * |
|
849 PyWeakref_GetObject(PyObject *ref) |
|
850 { |
|
851 if (ref == NULL || !PyWeakref_Check(ref)) { |
|
852 PyErr_BadInternalCall(); |
|
853 return NULL; |
|
854 } |
|
855 return PyWeakref_GET_OBJECT(ref); |
|
856 } |
|
857 |
|
858 /* Note that there's an inlined copy-paste of handle_callback() in gcmodule.c's |
|
859 * handle_weakrefs(). |
|
860 */ |
|
861 static void |
|
862 handle_callback(PyWeakReference *ref, PyObject *callback) |
|
863 { |
|
864 PyObject *cbresult = PyObject_CallFunctionObjArgs(callback, ref, NULL); |
|
865 |
|
866 if (cbresult == NULL) |
|
867 PyErr_WriteUnraisable(callback); |
|
868 else |
|
869 Py_DECREF(cbresult); |
|
870 } |
|
871 |
|
872 /* This function is called by the tp_dealloc handler to clear weak references. |
|
873 * |
|
874 * This iterates through the weak references for 'object' and calls callbacks |
|
875 * for those references which have one. It returns when all callbacks have |
|
876 * been attempted. |
|
877 */ |
|
878 void |
|
879 PyObject_ClearWeakRefs(PyObject *object) |
|
880 { |
|
881 PyWeakReference **list; |
|
882 |
|
883 if (object == NULL |
|
884 || !PyType_SUPPORTS_WEAKREFS(Py_TYPE(object)) |
|
885 || object->ob_refcnt != 0) { |
|
886 PyErr_BadInternalCall(); |
|
887 return; |
|
888 } |
|
889 list = GET_WEAKREFS_LISTPTR(object); |
|
890 /* Remove the callback-less basic and proxy references */ |
|
891 if (*list != NULL && (*list)->wr_callback == NULL) { |
|
892 clear_weakref(*list); |
|
893 if (*list != NULL && (*list)->wr_callback == NULL) |
|
894 clear_weakref(*list); |
|
895 } |
|
896 if (*list != NULL) { |
|
897 PyWeakReference *current = *list; |
|
898 Py_ssize_t count = _PyWeakref_GetWeakrefCount(current); |
|
899 int restore_error = PyErr_Occurred() ? 1 : 0; |
|
900 PyObject *err_type, *err_value, *err_tb; |
|
901 |
|
902 if (restore_error) |
|
903 PyErr_Fetch(&err_type, &err_value, &err_tb); |
|
904 if (count == 1) { |
|
905 PyObject *callback = current->wr_callback; |
|
906 |
|
907 current->wr_callback = NULL; |
|
908 clear_weakref(current); |
|
909 if (callback != NULL) { |
|
910 if (current->ob_refcnt > 0) |
|
911 handle_callback(current, callback); |
|
912 Py_DECREF(callback); |
|
913 } |
|
914 } |
|
915 else { |
|
916 PyObject *tuple; |
|
917 Py_ssize_t i = 0; |
|
918 |
|
919 tuple = PyTuple_New(count * 2); |
|
920 if (tuple == NULL) { |
|
921 if (restore_error) |
|
922 PyErr_Fetch(&err_type, &err_value, &err_tb); |
|
923 return; |
|
924 } |
|
925 |
|
926 for (i = 0; i < count; ++i) { |
|
927 PyWeakReference *next = current->wr_next; |
|
928 |
|
929 if (current->ob_refcnt > 0) |
|
930 { |
|
931 Py_INCREF(current); |
|
932 PyTuple_SET_ITEM(tuple, i * 2, (PyObject *) current); |
|
933 PyTuple_SET_ITEM(tuple, i * 2 + 1, current->wr_callback); |
|
934 } |
|
935 else { |
|
936 Py_DECREF(current->wr_callback); |
|
937 } |
|
938 current->wr_callback = NULL; |
|
939 clear_weakref(current); |
|
940 current = next; |
|
941 } |
|
942 for (i = 0; i < count; ++i) { |
|
943 PyObject *callback = PyTuple_GET_ITEM(tuple, i * 2 + 1); |
|
944 |
|
945 /* The tuple may have slots left to NULL */ |
|
946 if (callback != NULL) { |
|
947 PyObject *item = PyTuple_GET_ITEM(tuple, i * 2); |
|
948 handle_callback((PyWeakReference *)item, callback); |
|
949 } |
|
950 } |
|
951 Py_DECREF(tuple); |
|
952 } |
|
953 if (restore_error) |
|
954 PyErr_Restore(err_type, err_value, err_tb); |
|
955 } |
|
956 } |