PEP 205, Weak References -- initial checkin.
diff --git a/Modules/_weakref.c b/Modules/_weakref.c
new file mode 100644
index 0000000..3c03c3c
--- /dev/null
+++ b/Modules/_weakref.c
@@ -0,0 +1,757 @@
+#include "Python.h"
+#include "structmember.h"
+
+
+typedef struct _PyWeakReference PyWeakReference;
+
+struct _PyWeakReference {
+ PyObject_HEAD
+ PyObject *wr_object;
+ PyObject *wr_callback;
+ PyWeakReference *wr_prev;
+ PyWeakReference *wr_next;
+};
+
+
+#define GET_WEAKREFS_LISTPTR(o) \
+ ((PyWeakReference **) PyObject_GET_WEAKREFS_LISTPTR(o))
+
+static PyObject *
+ReferenceError;
+
+static PyWeakReference *
+free_list = NULL;
+
+staticforward PyTypeObject
+PyWeakReference_Type;
+
+static PyWeakReference *
+new_weakref(void)
+{
+ PyWeakReference *result;
+
+ if (free_list != NULL) {
+ result = free_list;
+ free_list = result->wr_next;
+ result->ob_type = &PyWeakReference_Type;
+ _Py_NewReference(result);
+ }
+ else {
+ result = PyObject_NEW(PyWeakReference, &PyWeakReference_Type);
+ }
+ 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 (self->wr_object != Py_None) {
+ PyWeakReference **list = GET_WEAKREFS_LISTPTR(self->wr_object);
+
+ 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)
+{
+ clear_weakref(self);
+ PyObject_GC_Fini((PyObject *)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 = self->wr_object;
+ Py_INCREF(object);
+ return (object);
+ }
+ return NULL;
+}
+
+
+static PyObject *
+weakref_repr(PyWeakReference *self)
+{
+ char buffer[256];
+ if (self->wr_object == Py_None) {
+ sprintf(buffer, "<weakref at %lx; dead>",
+ (long)(self));
+ }
+ else {
+ sprintf(buffer, "<weakref at %#lx; to '%s' at %#lx>",
+ (long)(self), self->wr_object->ob_type->tp_name,
+ (long)(self->wr_object));
+ }
+ return PyString_FromString(buffer);
+}
+
+
+statichere PyTypeObject
+PyWeakReference_Type = {
+ PyObject_HEAD_INIT(NULL)
+ 0,
+ "weakref",
+ sizeof(PyWeakReference) + PyGC_HEAD_SIZE,
+ 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*/
+ 0, /*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_GC,
+ 0, /*tp_doc*/
+ (traverseproc)gc_traverse, /*tp_traverse*/
+ (inquiry)gc_clear, /*tp_clear*/
+};
+
+
+static int
+proxy_checkref(PyWeakReference *proxy)
+{
+ if (proxy->wr_object == Py_None) {
+ PyErr_SetString(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(proxy->wr_object); \
+ }
+
+#define WRAP_BINARY(method, generic) \
+ static PyObject * \
+ method(PyWeakReference *proxy, PyObject *v) { \
+ if (!proxy_checkref(proxy)) { \
+ return NULL; \
+ } \
+ return generic(proxy->wr_object, v); \
+ }
+
+#define WRAP_TERNARY(method, generic) \
+ static PyObject * \
+ method(PyWeakReference *proxy, PyObject *v, PyObject *w) { \
+ if (!proxy_checkref(proxy)) { \
+ return NULL; \
+ } \
+ return generic(proxy->wr_object, 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(proxy->wr_object, fp, flags);
+}
+
+static PyObject *
+proxy_repr(PyWeakReference *proxy)
+{
+ char buf[160];
+ sprintf(buf, "<weakref at %p to %.100s at %p>", proxy,
+ proxy->wr_object->ob_type->tp_name, proxy->wr_object);
+ return PyString_FromString(buf);
+}
+
+
+static int
+proxy_setattr(PyWeakReference *proxy, PyObject *name, PyObject *value)
+{
+ if (!proxy_checkref(proxy))
+ return -1;
+ return PyObject_SetAttr(proxy->wr_object, name, value);
+}
+
+static int
+proxy_compare(PyWeakReference *proxy, PyObject *v)
+{
+ if (!proxy_checkref(proxy))
+ return -1;
+ return PyObject_Compare(proxy->wr_object, 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 = proxy->wr_object;
+ 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(proxy->wr_object, i, j);
+}
+
+static int
+proxy_ass_slice(PyWeakReference *proxy, int i, int j, PyObject *value)
+{
+ if (!proxy_checkref(proxy))
+ return -1;
+ return PySequence_SetSlice(proxy->wr_object, i, j, value);
+}
+
+static int
+proxy_contains(PyWeakReference *proxy, PyObject *value)
+{
+ if (!proxy_checkref(proxy))
+ return -1;
+ return PySequence_Contains(proxy->wr_object, value);
+}
+
+
+/* mapping slots */
+
+static int
+proxy_length(PyWeakReference *proxy)
+{
+ if (!proxy_checkref(proxy))
+ return -1;
+ return PyObject_Length(proxy->wr_object);
+}
+
+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(proxy->wr_object, 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*/
+};
+
+
+static PyTypeObject
+PyWeakProxy_Type = {
+ PyObject_HEAD_INIT(NULL)
+ 0,
+ "weakproxy",
+ sizeof(PyWeakReference) + PyGC_HEAD_SIZE,
+ 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_GC
+ |Py_TPFLAGS_CHECKTYPES, /*tp_flags*/
+ 0, /*tp_doc*/
+ (traverseproc)gc_traverse, /*tp_traverse*/
+ (inquiry)gc_clear, /*tp_clear*/
+};
+
+
+static PyTypeObject
+PyWeakCallableProxy_Type = {
+ PyObject_HEAD_INIT(NULL)
+ 0,
+ "weakcallableproxy",
+ sizeof(PyWeakReference) + PyGC_HEAD_SIZE,
+ 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_GC
+ |Py_TPFLAGS_CHECKTYPES, /*tp_flags*/
+ 0, /*tp_doc*/
+ (traverseproc)gc_traverse, /*tp_traverse*/
+ (inquiry)gc_clear, /*tp_clear*/
+};
+
+
+static long
+getweakrefcount(PyWeakReference *head)
+{
+ long count = 0;
+
+ while (head != NULL) {
+ ++count;
+ head = head->wr_next;
+ }
+ return count;
+}
+
+
+static PyObject *
+weakref_getweakrefcount(PyObject *self, PyObject *args)
+{
+ PyObject *result = NULL;
+ PyObject *object;
+
+ if (PyArg_ParseTuple(args, "O:getweakrefcount", &object)) {
+ if (PyType_SUPPORTS_WEAKREFS(object->ob_type)) {
+ PyWeakReference **list = GET_WEAKREFS_LISTPTR(object);
+
+ result = PyInt_FromLong(getweakrefcount(*list));
+ }
+ else
+ result = PyInt_FromLong(0);
+ }
+ return result;
+}
+
+
+static PyObject *
+weakref_getweakrefs(PyObject *self, PyObject *args)
+{
+ PyObject *result = NULL;
+ PyObject *object;
+
+ if (PyArg_ParseTuple(args, "O:getweakrefs", &object)) {
+ if (PyType_SUPPORTS_WEAKREFS(object->ob_type)) {
+ PyWeakReference **list = GET_WEAKREFS_LISTPTR(object);
+ long count = getweakrefcount(*list);
+
+ result = PyList_New(count);
+ if (result != NULL) {
+ PyWeakReference *current = *list;
+ long i;
+ for (i = 0; i < count; ++i) {
+ PyList_SET_ITEM(result, i, (PyObject *) current);
+ Py_INCREF(current);
+ current = current->wr_next;
+ }
+ }
+ }
+ else {
+ result = PyList_New(0);
+ }
+ }
+ return result;
+}
+
+
+/* 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 == &PyWeakReference_Type) {
+ *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;
+}
+
+
+static PyObject *
+weakref_ref(PyObject *self, PyObject *args)
+{
+ PyObject *object;
+ PyObject *callback = NULL;
+ PyWeakReference *result = NULL;
+
+ if (PyArg_ParseTuple(args, "O|O:new", &object, &callback)) {
+ PyWeakReference **list;
+ PyWeakReference *ref, *proxy;
+
+ if (!PyType_SUPPORTS_WEAKREFS(object->ob_type)) {
+ PyErr_Format(PyExc_TypeError,
+ "'%s' objects are not weakly referencable",
+ object->ob_type->tp_name);
+ return NULL;
+ }
+ list = GET_WEAKREFS_LISTPTR(object);
+ get_basic_refs(*list, &ref, &proxy);
+ if (callback == NULL) {
+ /* return existing weak reference if it exists */
+ result = ref;
+ Py_XINCREF(result);
+ }
+ if (result == NULL) {
+ result = new_weakref();
+ if (result != NULL) {
+ Py_XINCREF(callback);
+ result->wr_callback = callback;
+ result->wr_object = object;
+ 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_Init((PyObject *) result);
+ }
+ }
+ }
+ return (PyObject *) result;
+}
+
+
+static PyObject *
+weakref_proxy(PyObject *self, PyObject *args)
+{
+ PyObject *object;
+ PyObject *callback = NULL;
+ PyWeakReference *result = NULL;
+
+ if (PyArg_ParseTuple(args, "O|O:new", &object, &callback)) {
+ PyWeakReference **list;
+ PyWeakReference *ref, *proxy;
+
+ if (!PyType_SUPPORTS_WEAKREFS(object->ob_type)) {
+ PyErr_Format(PyExc_TypeError,
+ "'%s' objects are not weakly referencable",
+ object->ob_type->tp_name);
+ return NULL;
+ }
+ list = GET_WEAKREFS_LISTPTR(object);
+ get_basic_refs(*list, &ref, &proxy);
+ if (callback == NULL) {
+ /* attempt to return an existing weak reference if it exists */
+ result = proxy;
+ Py_XINCREF(result);
+ }
+ if (result == NULL) {
+ result = new_weakref();
+ if (result != NULL) {
+ PyWeakReference *prev;
+
+ if (PyCallable_Check(object))
+ result->ob_type = &PyWeakCallableProxy_Type;
+ else
+ result->ob_type = &PyWeakProxy_Type;
+ result->wr_object = object;
+ 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_Init((PyObject *) result);
+ }
+ }
+ }
+ return (PyObject *) result;
+}
+
+
+/* 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 returns true if the object should be deallocated, and false if the
+ * object is resurrected and deallocation should be aborted.
+ *
+ * This iterates through the weak references for 'object' and calls callbacks
+ * until one resurrects the object, at which point it stops invalidating
+ * weak references and returns false.
+ */
+static int
+cleanup_helper(PyObject *object)
+{
+ PyWeakReference **list;
+
+ if (object == NULL
+ || !PyType_SUPPORTS_WEAKREFS(object->ob_type)
+ || object->ob_refcnt != 0) {
+ PyErr_BadInternalCall();
+ /* not sure what we should return here */
+ return 1;
+ }
+ list = GET_WEAKREFS_LISTPTR(object);
+ while (*list != NULL) {
+ PyWeakReference *current = *list;
+ PyObject *callback = current->wr_callback;
+
+ Py_XINCREF(callback);
+ clear_weakref(current);
+ if (callback != NULL) {
+ PyObject *cbresult;
+
+ cbresult = PyObject_CallFunction(callback, "O", current);
+ if (cbresult == NULL)
+ PyErr_WriteUnraisable(callback);
+ else
+ Py_DECREF(cbresult);
+ Py_DECREF(callback);
+ }
+ }
+ return (object->ob_refcnt > 0 ? 0 : 1);
+}
+
+
+static PyMethodDef
+weakref_functions[] = {
+ {"getweakrefcount", weakref_getweakrefcount, METH_VARARGS,
+ "getweakrefcount(object) -- return the number of weak references\n"
+ "to 'object'."},
+ {"getweakrefs", weakref_getweakrefs, METH_VARARGS,
+ "getweakrefs(object) -- return a list of all weak reference objects\n"
+ "that point to 'object'."},
+ {"proxy", weakref_proxy, METH_VARARGS,
+ "proxy(object[, callback]) -- create a proxy object that weakly\n"
+ "references 'object'. 'callback', if given, is called with a\n"
+ "reference to 'object' when it is about to be finalized."},
+ {"ref", weakref_ref, METH_VARARGS,
+ "new(object[, callback]) -- create a weak reference to 'object';\n"
+ "when 'object' is finalized, 'callback' will be called and passed\n"
+ "a reference to 'object'."},
+ {NULL, NULL, 0, NULL}
+};
+
+
+void
+init_weakref(void)
+{
+ PyObject *m;
+
+ PyWeakReference_Type.ob_type = &PyType_Type;
+ PyWeakProxy_Type.ob_type = &PyType_Type;
+ PyWeakCallableProxy_Type.ob_type = &PyType_Type;
+ m = Py_InitModule3("_weakref", weakref_functions,
+ "Weak-reference support module.");
+ if (m != NULL) {
+ PyObject_ClearWeakRefs = cleanup_helper;
+ Py_INCREF(&PyWeakReference_Type);
+ PyModule_AddObject(m, "ReferenceType",
+ (PyObject *) &PyWeakReference_Type);
+ Py_INCREF(&PyWeakProxy_Type);
+ PyModule_AddObject(m, "ProxyType",
+ (PyObject *) &PyWeakProxy_Type);
+ Py_INCREF(&PyWeakCallableProxy_Type);
+ PyModule_AddObject(m, "CallableProxyType",
+ (PyObject *) &PyWeakCallableProxy_Type);
+ ReferenceError = PyErr_NewException("weakref.ReferenceError",
+ PyExc_RuntimeError, NULL);
+ if (ReferenceError != NULL)
+ PyModule_AddObject(m, "ReferenceError", ReferenceError);
+ }
+}