mirror of
https://github.com/python/cpython
synced 2024-09-16 00:17:02 +00:00
82f1480d63
tracked as soon as it is clear; this can decrease the number of roots for the cycle detector sooner rather than later in applications which hold on to weak references beyond the time of the invalidation.
805 lines
23 KiB
C
805 lines
23 KiB
C
#include "Python.h"
|
|
#include "structmember.h"
|
|
|
|
|
|
typedef struct _PyWeakReference PyWeakReference;
|
|
|
|
struct _PyWeakReference {
|
|
PyObject_HEAD
|
|
PyObject *wr_object;
|
|
PyObject *wr_callback;
|
|
long hash;
|
|
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((PyObject *)result);
|
|
}
|
|
else {
|
|
result = PyObject_NEW(PyWeakReference, &PyWeakReference_Type);
|
|
}
|
|
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 (self->wr_object != Py_None) {
|
|
PyWeakReference **list = GET_WEAKREFS_LISTPTR(self->wr_object);
|
|
|
|
PyObject_GC_Fini((PyObject *)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)
|
|
{
|
|
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 = self->wr_object;
|
|
Py_INCREF(object);
|
|
return (object);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
static long
|
|
weakref_hash(PyWeakReference *self)
|
|
{
|
|
if (self->hash != -1)
|
|
return self->hash;
|
|
if (self->wr_object == Py_None) {
|
|
PyErr_SetString(PyExc_TypeError, "weak object has gone away");
|
|
return -1;
|
|
}
|
|
self->hash = PyObject_Hash(self->wr_object);
|
|
return self->hash;
|
|
}
|
|
|
|
|
|
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);
|
|
}
|
|
|
|
/* 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 (self->wr_object == Py_None || other->wr_object == Py_None) {
|
|
PyObject *res = self==other ? Py_True : Py_False;
|
|
Py_INCREF(res);
|
|
return res;
|
|
}
|
|
return PyObject_RichCompare(self->wr_object, other->wr_object, op);
|
|
}
|
|
|
|
|
|
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*/
|
|
(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_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 (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 char weakref_getweakrefcount__doc__[] =
|
|
"getweakrefcount(object) -- return the number of weak references\n"
|
|
"to 'object'.";
|
|
|
|
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 char weakref_getweakrefs__doc__[] =
|
|
"getweakrefs(object) -- return a list of all weak reference objects\n"
|
|
"that point to 'object'.";
|
|
|
|
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 char weakref_ref__doc__[] =
|
|
"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'.";
|
|
|
|
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 char weakref_proxy__doc__[] =
|
|
"proxy(object[, callback]) -- create a proxy object that weakly\n"
|
|
"references 'object'. 'callback', if given, is called with a\n"
|
|
"reference to the proxy when it is about to be finalized.";
|
|
|
|
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 iterates through the weak references for 'object' and calls callbacks
|
|
* for those references which have one. It returns when all callbacks have
|
|
* been attempted.
|
|
*/
|
|
static void
|
|
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;
|
|
}
|
|
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;
|
|
}
|
|
|
|
|
|
static PyMethodDef
|
|
weakref_functions[] = {
|
|
{"getweakrefcount", weakref_getweakrefcount, METH_VARARGS,
|
|
weakref_getweakrefcount__doc__},
|
|
{"getweakrefs", weakref_getweakrefs, METH_VARARGS,
|
|
weakref_getweakrefs__doc__},
|
|
{"proxy", weakref_proxy, METH_VARARGS,
|
|
weakref_proxy__doc__},
|
|
{"ref", weakref_ref, METH_VARARGS,
|
|
weakref_ref__doc__},
|
|
{NULL, NULL, 0, NULL}
|
|
};
|
|
|
|
|
|
DL_EXPORT(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);
|
|
}
|
|
}
|