diff options
| -rw-r--r-- | Include/weakrefobject.h | 50 | ||||
| -rw-r--r-- | Objects/weakrefobject.c | 715 |
2 files changed, 765 insertions, 0 deletions
diff --git a/Include/weakrefobject.h b/Include/weakrefobject.h new file mode 100644 index 0000000..3886ea5 --- /dev/null +++ b/Include/weakrefobject.h @@ -0,0 +1,50 @@ +/* Weak references objects for Python. */ + +#ifndef Py_WEAKREFOBJECT_H +#define Py_WEAKREFOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + + +typedef struct _PyWeakReference PyWeakReference; + +struct _PyWeakReference { + PyObject_HEAD + PyObject *wr_object; + PyObject *wr_callback; + long hash; + PyWeakReference *wr_prev; + PyWeakReference *wr_next; +}; + +extern DL_IMPORT(PyTypeObject) _PyWeakref_RefType; +extern DL_IMPORT(PyTypeObject) _PyWeakref_ProxyType; +extern DL_IMPORT(PyTypeObject) _PyWeakref_CallableProxyType; + +extern DL_IMPORT(PyObject *) PyErr_ReferenceError; + +#define PyWeakref_CheckRef(op) \ + ((op)->ob_type == &_PyWeakref_RefType) +#define PyWeakref_CheckProxy(op) \ + (((op)->ob_type == &_PyWeakref_ProxyType) || \ + ((op)->ob_type == &_PyWeakref_CallableProxyType)) +#define PyWeakref_Check(op) \ + (PyWeakref_CheckRef(op) || PyWeakref_CheckProxy(op)) + + +extern DL_IMPORT(PyObject *) PyWeakref_NewRef(PyObject *ob, + PyObject *callback); +extern DL_IMPORT(PyObject *) PyWeakref_NewProxy(PyObject *ob, + PyObject *callback); +extern DL_IMPORT(PyObject *) PyWeakref_GetObject(PyObject *ref); + +extern DL_IMPORT(long) _PyWeakref_GetWeakrefCount(PyWeakReference *head); + +#define PyWeakref_GET_OBJECT(ref) (((PyWeakReference *)(ref))->wr_object) + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_WEAKREFOBJECT_H */ diff --git a/Objects/weakrefobject.c b/Objects/weakrefobject.c new file mode 100644 index 0000000..56ecfb3 --- /dev/null +++ b/Objects/weakrefobject.c @@ -0,0 +1,715 @@ +#include "Python.h" +#include "structmember.h" + + +#define GET_WEAKREFS_LISTPTR(o) \ + ((PyWeakReference **) PyObject_GET_WEAKREFS_LISTPTR(o)) + +static PyWeakReference * +free_list = NULL; + + +long +_PyWeakref_GetWeakrefCount(PyWeakReference *head) +{ + long count = 0; + + while (head != NULL) { + ++count; + head = head->wr_next; + } + return count; +} + + +static PyWeakReference * +new_weakref(void) +{ + PyWeakReference *result; + + if (free_list != NULL) { + result = free_list; + free_list = result->wr_next; + result->ob_type = &_PyWeakref_RefType; + _Py_NewReference((PyObject *)result); + } + else { + result = PyObject_GC_New(PyWeakReference, &_PyWeakref_RefType); + } + if (result) + result->hash = -1; + return result; +} + + +/* This function clears the passed-in reference and removes it from the + * list of weak references for the referent. This is the only code that + * removes an item from the doubly-linked list of weak references for an + * object; it is also responsible for clearing the callback slot. + */ +static void +clear_weakref(PyWeakReference *self) +{ + PyObject *callback = self->wr_callback; + + if (PyWeakref_GET_OBJECT(self) != Py_None) { + PyWeakReference **list = GET_WEAKREFS_LISTPTR( + PyWeakref_GET_OBJECT(self)); + + if (*list == self) + *list = self->wr_next; + self->wr_object = Py_None; + self->wr_callback = NULL; + if (self->wr_prev != NULL) + self->wr_prev->wr_next = self->wr_next; + if (self->wr_next != NULL) + self->wr_next->wr_prev = self->wr_prev; + self->wr_prev = NULL; + self->wr_next = NULL; + Py_XDECREF(callback); + } +} + + +static void +weakref_dealloc(PyWeakReference *self) +{ + PyObject_GC_UnTrack((PyObject *)self); + clear_weakref(self); + self->wr_next = free_list; + free_list = self; +} + + +static int +gc_traverse(PyWeakReference *self, visitproc visit, void *arg) +{ + if (self->wr_callback != NULL) + return visit(self->wr_callback, arg); + return 0; +} + + +static int +gc_clear(PyWeakReference *self) +{ + clear_weakref(self); + return 0; +} + + +static PyObject * +weakref_call(PyWeakReference *self, PyObject *args, PyObject *kw) +{ + static char *argnames[] = {NULL}; + + if (PyArg_ParseTupleAndKeywords(args, kw, ":__call__", argnames)) { + PyObject *object = PyWeakref_GET_OBJECT(self); + Py_INCREF(object); + return (object); + } + return NULL; +} + + +static long +weakref_hash(PyWeakReference *self) +{ + if (self->hash != -1) + return self->hash; + if (PyWeakref_GET_OBJECT(self) == Py_None) { + PyErr_SetString(PyExc_TypeError, "weak object has gone away"); + return -1; + } + self->hash = PyObject_Hash(PyWeakref_GET_OBJECT(self)); + return self->hash; +} + + +static PyObject * +weakref_repr(PyWeakReference *self) +{ + char buffer[256]; + if (PyWeakref_GET_OBJECT(self) == Py_None) { + sprintf(buffer, "<weakref at %lx; dead>", + (long)(self)); + } + else { + sprintf(buffer, "<weakref at %#lx; to '%s' at %#lx>", + (long)(self), PyWeakref_GET_OBJECT(self)->ob_type->tp_name, + (long)(PyWeakref_GET_OBJECT(self))); + } + return PyString_FromString(buffer); +} + +/* Weak references only support equality, not ordering. Two weak references + are equal if the underlying objects are equal. If the underlying object has + gone away, they are equal if they are identical. */ + +static PyObject * +weakref_richcompare(PyWeakReference* self, PyWeakReference* other, int op) +{ + if (op != Py_EQ || self->ob_type != other->ob_type) { + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } + if (PyWeakref_GET_OBJECT(self) == Py_None + || PyWeakref_GET_OBJECT(other) == Py_None) { + PyObject *res = self==other ? Py_True : Py_False; + Py_INCREF(res); + return res; + } + return PyObject_RichCompare(PyWeakref_GET_OBJECT(self), + PyWeakref_GET_OBJECT(other), op); +} + + +PyTypeObject +_PyWeakref_RefType = { + PyObject_HEAD_INIT(&PyType_Type) + 0, + "weakref", + sizeof(PyWeakReference), + 0, + (destructor)weakref_dealloc,/*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + (reprfunc)weakref_repr, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + (hashfunc)weakref_hash, /*tp_hash*/ + (ternaryfunc)weakref_call, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_RICHCOMPARE, + 0, /*tp_doc*/ + (traverseproc)gc_traverse, /*tp_traverse*/ + (inquiry)gc_clear, /*tp_clear*/ + (richcmpfunc)weakref_richcompare, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ +}; + + +static int +proxy_checkref(PyWeakReference *proxy) +{ + if (PyWeakref_GET_OBJECT(proxy) == Py_None) { + PyErr_SetString(PyExc_ReferenceError, + "weakly-referenced object no longer exists"); + return 0; + } + return 1; +} + + +#define WRAP_UNARY(method, generic) \ + static PyObject * \ + method(PyWeakReference *proxy) { \ + if (!proxy_checkref(proxy)) { \ + return NULL; \ + } \ + return generic(PyWeakref_GET_OBJECT(proxy)); \ + } + +#define WRAP_BINARY(method, generic) \ + static PyObject * \ + method(PyWeakReference *proxy, PyObject *v) { \ + if (!proxy_checkref(proxy)) { \ + return NULL; \ + } \ + return generic(PyWeakref_GET_OBJECT(proxy), v); \ + } + +#define WRAP_TERNARY(method, generic) \ + static PyObject * \ + method(PyWeakReference *proxy, PyObject *v, PyObject *w) { \ + if (!proxy_checkref(proxy)) { \ + return NULL; \ + } \ + return generic(PyWeakref_GET_OBJECT(proxy), v, w); \ + } + + +/* direct slots */ + +WRAP_BINARY(proxy_getattr, PyObject_GetAttr) +WRAP_UNARY(proxy_str, PyObject_Str) +WRAP_TERNARY(proxy_call, PyEval_CallObjectWithKeywords) + +static int +proxy_print(PyWeakReference *proxy, FILE *fp, int flags) +{ + if (!proxy_checkref(proxy)) + return -1; + return PyObject_Print(PyWeakref_GET_OBJECT(proxy), fp, flags); +} + +static PyObject * +proxy_repr(PyWeakReference *proxy) +{ + char buf[160]; + sprintf(buf, "<weakref at %p to %.100s at %p>", proxy, + PyWeakref_GET_OBJECT(proxy)->ob_type->tp_name, + PyWeakref_GET_OBJECT(proxy)); + return PyString_FromString(buf); +} + + +static int +proxy_setattr(PyWeakReference *proxy, PyObject *name, PyObject *value) +{ + if (!proxy_checkref(proxy)) + return -1; + return PyObject_SetAttr(PyWeakref_GET_OBJECT(proxy), name, value); +} + +static int +proxy_compare(PyWeakReference *proxy, PyObject *v) +{ + if (!proxy_checkref(proxy)) + return -1; + return PyObject_Compare(PyWeakref_GET_OBJECT(proxy), v); +} + +/* number slots */ +WRAP_BINARY(proxy_add, PyNumber_Add) +WRAP_BINARY(proxy_sub, PyNumber_Subtract) +WRAP_BINARY(proxy_mul, PyNumber_Multiply) +WRAP_BINARY(proxy_div, PyNumber_Divide) +WRAP_BINARY(proxy_mod, PyNumber_Remainder) +WRAP_BINARY(proxy_divmod, PyNumber_Divmod) +WRAP_TERNARY(proxy_pow, PyNumber_Power) +WRAP_UNARY(proxy_neg, PyNumber_Negative) +WRAP_UNARY(proxy_pos, PyNumber_Positive) +WRAP_UNARY(proxy_abs, PyNumber_Absolute) +WRAP_UNARY(proxy_invert, PyNumber_Invert) +WRAP_BINARY(proxy_lshift, PyNumber_Lshift) +WRAP_BINARY(proxy_rshift, PyNumber_Rshift) +WRAP_BINARY(proxy_and, PyNumber_And) +WRAP_BINARY(proxy_xor, PyNumber_Xor) +WRAP_BINARY(proxy_or, PyNumber_Or) +WRAP_UNARY(proxy_int, PyNumber_Int) +WRAP_UNARY(proxy_long, PyNumber_Long) +WRAP_UNARY(proxy_float, PyNumber_Float) +WRAP_BINARY(proxy_iadd, PyNumber_InPlaceAdd) +WRAP_BINARY(proxy_isub, PyNumber_InPlaceSubtract) +WRAP_BINARY(proxy_imul, PyNumber_InPlaceMultiply) +WRAP_BINARY(proxy_idiv, PyNumber_InPlaceDivide) +WRAP_BINARY(proxy_imod, PyNumber_InPlaceRemainder) +WRAP_TERNARY(proxy_ipow, PyNumber_InPlacePower) +WRAP_BINARY(proxy_ilshift, PyNumber_InPlaceLshift) +WRAP_BINARY(proxy_irshift, PyNumber_InPlaceRshift) +WRAP_BINARY(proxy_iand, PyNumber_InPlaceAnd) +WRAP_BINARY(proxy_ixor, PyNumber_InPlaceXor) +WRAP_BINARY(proxy_ior, PyNumber_InPlaceOr) + +static int +proxy_nonzero(PyWeakReference *proxy) +{ + PyObject *o = PyWeakref_GET_OBJECT(proxy); + if (!proxy_checkref(proxy)) + return 1; + if (o->ob_type->tp_as_number && + o->ob_type->tp_as_number->nb_nonzero) + return (*o->ob_type->tp_as_number->nb_nonzero)(o); + else + return 1; +} + +/* sequence slots */ + +static PyObject * +proxy_slice(PyWeakReference *proxy, int i, int j) +{ + if (!proxy_checkref(proxy)) + return NULL; + return PySequence_GetSlice(PyWeakref_GET_OBJECT(proxy), i, j); +} + +static int +proxy_ass_slice(PyWeakReference *proxy, int i, int j, PyObject *value) +{ + if (!proxy_checkref(proxy)) + return -1; + return PySequence_SetSlice(PyWeakref_GET_OBJECT(proxy), i, j, value); +} + +static int +proxy_contains(PyWeakReference *proxy, PyObject *value) +{ + if (!proxy_checkref(proxy)) + return -1; + return PySequence_Contains(PyWeakref_GET_OBJECT(proxy), value); +} + + +/* mapping slots */ + +static int +proxy_length(PyWeakReference *proxy) +{ + if (!proxy_checkref(proxy)) + return -1; + return PyObject_Length(PyWeakref_GET_OBJECT(proxy)); +} + +WRAP_BINARY(proxy_getitem, PyObject_GetItem) + +static int +proxy_setitem(PyWeakReference *proxy, PyObject *key, PyObject *value) +{ + if (!proxy_checkref(proxy)) + return -1; + return PyObject_SetItem(PyWeakref_GET_OBJECT(proxy), key, value); +} + + +static PyNumberMethods proxy_as_number = { + (binaryfunc)proxy_add, /*nb_add*/ + (binaryfunc)proxy_sub, /*nb_subtract*/ + (binaryfunc)proxy_mul, /*nb_multiply*/ + (binaryfunc)proxy_div, /*nb_divide*/ + (binaryfunc)proxy_mod, /*nb_remainder*/ + (binaryfunc)proxy_divmod, /*nb_divmod*/ + (ternaryfunc)proxy_pow, /*nb_power*/ + (unaryfunc)proxy_neg, /*nb_negative*/ + (unaryfunc)proxy_pos, /*nb_positive*/ + (unaryfunc)proxy_abs, /*nb_absolute*/ + (inquiry)proxy_nonzero, /*nb_nonzero*/ + (unaryfunc)proxy_invert, /*nb_invert*/ + (binaryfunc)proxy_lshift, /*nb_lshift*/ + (binaryfunc)proxy_rshift, /*nb_rshift*/ + (binaryfunc)proxy_and, /*nb_and*/ + (binaryfunc)proxy_xor, /*nb_xor*/ + (binaryfunc)proxy_or, /*nb_or*/ + (coercion)0, /*nb_coerce*/ + (unaryfunc)proxy_int, /*nb_int*/ + (unaryfunc)proxy_long, /*nb_long*/ + (unaryfunc)proxy_float, /*nb_float*/ + (unaryfunc)0, /*nb_oct*/ + (unaryfunc)0, /*nb_hex*/ + (binaryfunc)proxy_iadd, /*nb_inplace_add*/ + (binaryfunc)proxy_isub, /*nb_inplace_subtract*/ + (binaryfunc)proxy_imul, /*nb_inplace_multiply*/ + (binaryfunc)proxy_idiv, /*nb_inplace_divide*/ + (binaryfunc)proxy_imod, /*nb_inplace_remainder*/ + (ternaryfunc)proxy_ipow, /*nb_inplace_power*/ + (binaryfunc)proxy_ilshift, /*nb_inplace_lshift*/ + (binaryfunc)proxy_irshift, /*nb_inplace_rshift*/ + (binaryfunc)proxy_iand, /*nb_inplace_and*/ + (binaryfunc)proxy_ixor, /*nb_inplace_xor*/ + (binaryfunc)proxy_ior, /*nb_inplace_or*/ +}; + +static PySequenceMethods proxy_as_sequence = { + (inquiry)proxy_length, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + 0, /*sq_item*/ + (intintargfunc)proxy_slice, /*sq_slice*/ + 0, /*sq_ass_item*/ + (intintobjargproc)proxy_ass_slice, /*sq_ass_slice*/ + (objobjproc)proxy_contains, /* sq_contains */ +}; + +static PyMappingMethods proxy_as_mapping = { + (inquiry)proxy_length, /*mp_length*/ + (binaryfunc)proxy_getitem, /*mp_subscript*/ + (objobjargproc)proxy_setitem, /*mp_ass_subscript*/ +}; + + +PyTypeObject +_PyWeakref_ProxyType = { + PyObject_HEAD_INIT(&PyType_Type) + 0, + "weakproxy", + sizeof(PyWeakReference), + 0, + /* methods */ + (destructor)weakref_dealloc,/*tp_dealloc*/ + (printfunc)proxy_print, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + (cmpfunc)proxy_compare, /*tp_compare*/ + (unaryfunc)proxy_repr, /*tp_repr*/ + &proxy_as_number, /*tp_as_number*/ + &proxy_as_sequence, /*tp_as_sequence*/ + &proxy_as_mapping, /*tp_as_mapping*/ + 0, /*tp_hash*/ + (ternaryfunc)0, /*tp_call*/ + (unaryfunc)proxy_str, /*tp_str*/ + (getattrofunc)proxy_getattr,/*tp_getattro*/ + (setattrofunc)proxy_setattr,/*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC + |Py_TPFLAGS_CHECKTYPES, /*tp_flags*/ + 0, /*tp_doc*/ + (traverseproc)gc_traverse, /*tp_traverse*/ + (inquiry)gc_clear, /*tp_clear*/ +}; + + +PyTypeObject +_PyWeakref_CallableProxyType = { + PyObject_HEAD_INIT(&PyType_Type) + 0, + "weakcallableproxy", + sizeof(PyWeakReference), + 0, + /* methods */ + (destructor)weakref_dealloc,/*tp_dealloc*/ + (printfunc)proxy_print, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + (cmpfunc)proxy_compare, /*tp_compare*/ + (unaryfunc)proxy_repr, /*tp_repr*/ + &proxy_as_number, /*tp_as_number*/ + &proxy_as_sequence, /*tp_as_sequence*/ + &proxy_as_mapping, /*tp_as_mapping*/ + 0, /*tp_hash*/ + (ternaryfunc)proxy_call, /*tp_call*/ + (unaryfunc)proxy_str, /*tp_str*/ + (getattrofunc)proxy_getattr,/*tp_getattro*/ + (setattrofunc)proxy_setattr,/*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC + |Py_TPFLAGS_CHECKTYPES, /*tp_flags*/ + 0, /*tp_doc*/ + (traverseproc)gc_traverse, /*tp_traverse*/ + (inquiry)gc_clear, /*tp_clear*/ +}; + + +/* Given the head of an object's list of weak references, extract the + * two callback-less refs (ref and proxy). Used to determine if the + * shared references exist and to determine the back link for newly + * inserted references. + */ +static void +get_basic_refs(PyWeakReference *head, + PyWeakReference **refp, PyWeakReference **proxyp) +{ + *refp = NULL; + *proxyp = NULL; + + if (head != NULL && head->wr_callback == NULL) { + if (head->ob_type == &_PyWeakref_RefType) { + *refp = head; + head = head->wr_next; + } + if (head != NULL && head->wr_callback == NULL) { + *proxyp = head; + head = head->wr_next; + } + } +} + +/* Insert 'newref' in the list after 'prev'. Both must be non-NULL. */ +static void +insert_after(PyWeakReference *newref, PyWeakReference *prev) +{ + newref->wr_prev = prev; + newref->wr_next = prev->wr_next; + if (prev->wr_next != NULL) + prev->wr_next->wr_prev = newref; + prev->wr_next = newref; +} + +/* Insert 'newref' at the head of the list; 'list' points to the variable + * that stores the head. + */ +static void +insert_head(PyWeakReference *newref, PyWeakReference **list) +{ + PyWeakReference *next = *list; + + newref->wr_prev = NULL; + newref->wr_next = next; + if (next != NULL) + next->wr_prev = newref; + *list = newref; +} + + +PyObject * +PyWeakref_NewRef(PyObject *ob, PyObject *callback) +{ + PyWeakReference *result = NULL; + PyWeakReference **list; + PyWeakReference *ref, *proxy; + + if (!PyType_SUPPORTS_WEAKREFS(ob->ob_type)) { + PyErr_Format(PyExc_TypeError, + "'%s' objects are not weakly referencable", + ob->ob_type->tp_name); + return NULL; + } + list = GET_WEAKREFS_LISTPTR(ob); + get_basic_refs(*list, &ref, &proxy); + if (callback == NULL || callback == Py_None) + /* return existing weak reference if it exists */ + result = ref; + if (result != NULL) + Py_XINCREF(result); + else { + result = new_weakref(); + if (result != NULL) { + Py_XINCREF(callback); + result->wr_callback = callback; + result->wr_object = ob; + if (callback == NULL) { + insert_head(result, list); + } + else { + PyWeakReference *prev = (proxy == NULL) ? ref : proxy; + + if (prev == NULL) + insert_head(result, list); + else + insert_after(result, prev); + } + PyObject_GC_Track(result); + } + } + return (PyObject *) result; +} + + +PyObject * +PyWeakref_NewProxy(PyObject *ob, PyObject *callback) +{ + PyWeakReference *result = NULL; + PyWeakReference **list; + PyWeakReference *ref, *proxy; + + if (!PyType_SUPPORTS_WEAKREFS(ob->ob_type)) { + PyErr_Format(PyExc_TypeError, + "'%s' objects are not weakly referencable", + ob->ob_type->tp_name); + return NULL; + } + list = GET_WEAKREFS_LISTPTR(ob); + get_basic_refs(*list, &ref, &proxy); + if (callback == NULL) + /* attempt to return an existing weak reference if it exists */ + result = proxy; + if (result != NULL) + Py_XINCREF(result); + else { + result = new_weakref(); + if (result != NULL) { + PyWeakReference *prev; + + if (PyCallable_Check(ob)) + result->ob_type = &_PyWeakref_CallableProxyType; + else + result->ob_type = &_PyWeakref_ProxyType; + result->wr_object = ob; + Py_XINCREF(callback); + result->wr_callback = callback; + if (callback == NULL) + prev = ref; + else + prev = (proxy == NULL) ? ref : proxy; + + if (prev == NULL) + insert_head(result, list); + else + insert_after(result, prev); + PyObject_GC_Track(result); + } + } + return (PyObject *) result; +} + + +PyObject * +PyWeakref_GetObject(PyObject *ref) +{ + if (ref == NULL || !PyWeakref_Check(ref)) { + PyErr_BadInternalCall(); + return NULL; + } + return PyWeakref_GET_OBJECT(ref); +} + + +/* This is the implementation of the PyObject_ClearWeakRefs() function; it + * is installed in the init_weakref() function. It is called by the + * tp_dealloc handler to clear weak references. + * + * This iterates through the weak references for 'object' and calls callbacks + * for those references which have one. It returns when all callbacks have + * been attempted. + */ +void +PyObject_ClearWeakRefs(PyObject *object) +{ + PyWeakReference **list; + + if (object == NULL + || !PyType_SUPPORTS_WEAKREFS(object->ob_type) + || object->ob_refcnt != 0) { + PyErr_BadInternalCall(); + return; + } + list = GET_WEAKREFS_LISTPTR(object); + /* Remove the callback-less basic and proxy references */ + if (*list != NULL && (*list)->wr_callback == NULL) { + clear_weakref(*list); + if (*list != NULL && (*list)->wr_callback == NULL) + clear_weakref(*list); + } + if (*list != NULL) { + int count = _PyWeakref_GetWeakrefCount(*list); + + if (count == 1) { + PyWeakReference *current = *list; + PyObject *callback = current->wr_callback; + PyObject *cbresult; + + Py_INCREF(callback); + clear_weakref(current); + cbresult = PyObject_CallFunction(callback, "O", current); + if (cbresult == NULL) + PyErr_WriteUnraisable(callback); + else + Py_DECREF(cbresult); + Py_DECREF(callback); + } + else { + PyObject *tuple = PyTuple_New(count * 2); + PyWeakReference *current = *list; + int i = 0; + + for (i = 0; i < count; ++i) { + PyWeakReference *next = current->wr_next; + + Py_INCREF(current); + PyTuple_SET_ITEM(tuple, i * 2, (PyObject *) current); + PyTuple_SET_ITEM(tuple, i * 2 + 1, current->wr_callback); + current->wr_callback = NULL; + next = current->wr_next; + clear_weakref(current); + current = next; + } + for (i = 0; i < count; ++i) { + PyObject *current = PyTuple_GET_ITEM(tuple, i * 2); + PyObject *callback = PyTuple_GET_ITEM(tuple, i * 2 + 1); + PyObject *cbresult = PyObject_CallFunction(callback, "O", + current); + if (cbresult == NULL) + PyErr_WriteUnraisable(callback); + else + Py_DECREF(cbresult); + } + Py_DECREF(tuple); + } + } +} |