#include "Python.h"

#include "pycore_critical_section.h"

#include "pycore_lock.h"

#include "pycore_modsupport.h" // _PyArg_NoKwnames()

#include "pycore_object.h" // _PyObject_GET_WEAKREFS_LISTPTR()

#include "pycore_pyerrors.h" // _PyErr_ChainExceptions1()

#include "pycore_pystate.h"

#include "pycore_weakref.h" // _PyWeakref_GET_REF()

#ifdef Py_GIL_DISABLED

#define GET_WEAKREFS_LISTPTR(o) \

((PyWeakReference **) _PyObject_GET_WEAKREFS_LISTPTR(o))

_PyWeakref_GetWeakrefCount(PyObject *obj)

{

if (!_PyType_SUPPORTS_WEAKREFS(Py_TYPE(obj))) {

return 0;

}

LOCK_WEAKREFS(obj);

Py_ssize_t count = 0;

PyWeakReference *head = *GET_WEAKREFS_LISTPTR(obj);

while (head != NULL) {

++count;

head = head->wr_next;

}

UNLOCK_WEAKREFS(obj);

return count;

}

static PyObject *weakref_vectorcall(PyObject *self, PyObject *const *args, size_t nargsf, PyObject *kwnames);

static void

init_weakref(PyWeakReference *self, PyObject *ob, PyObject *callback)

{

self->hash = -1;

self->wr_object = ob;

self->wr_prev = NULL;

self->wr_next = NULL;

self->wr_callback = Py_XNewRef(callback);

self->vectorcall = weakref_vectorcall;

#ifdef Py_GIL_DISABLED

self->weakrefs_lock = &WEAKREF_LIST_LOCK(ob);

_PyObject_SetMaybeWeakref(ob);

_PyObject_SetMaybeWeakref((PyObject *)self);

}

static void

clear_weakref_lock_held(PyWeakReference *self, PyObject **callback)

{

if (self->wr_object != Py_None) {

PyWeakReference **list = GET_WEAKREFS_LISTPTR(self->wr_object);

if (*list == self) {

/* If 'self' is the end of the list (and thus self->wr_next ==

FT_ATOMIC_STORE_PTR(*list, self->wr_next);

}

FT_ATOMIC_STORE_PTR(self->wr_object, Py_None);

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;

}

if (callback != NULL) {

*callback = self->wr_callback;

self->wr_callback = NULL;

}

}

static void

clear_weakref(PyWeakReference *self)

{

PyObject *callback = NULL;

// self->wr_object may be Py_None if the GC cleared the weakref, so lock

// using the pointer in the weakref.

LOCK_WEAKREFS_FOR_WR(self);

clear_weakref_lock_held(self, &callback);

UNLOCK_WEAKREFS_FOR_WR(self);

Py_XDECREF(callback);

}

_PyWeakref_ClearRef(PyWeakReference *self)

{

assert(self != NULL);

assert(PyWeakref_Check(self));

clear_weakref_lock_held(self, NULL);

}

static void

weakref_dealloc(PyObject *self)

{

PyObject_GC_UnTrack(self);

clear_weakref((PyWeakReference *) self);

Py_TYPE(self)->tp_free(self);

}

static int

gc_traverse(PyWeakReference *self, visitproc visit, void *arg)

{

Py_VISIT(self->wr_callback);

return 0;

}

static int

gc_clear(PyWeakReference *self)

{

PyObject *callback;

// The world is stopped during GC in free-threaded builds. It's safe to

// call this without holding the lock.

clear_weakref_lock_held(self, &callback);

Py_XDECREF(callback);

return 0;

}

static PyObject *

weakref_vectorcall(PyObject *self, PyObject *const *args,

size_t nargsf, PyObject *kwnames)

{

if (!_PyArg_NoKwnames("weakref", kwnames)) {

return NULL;

}

Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);

if (!_PyArg_CheckPositional("weakref", nargs, 0, 0)) {

return NULL;

}

PyObject *obj = _PyWeakref_GET_REF(self);

if (obj == NULL) {

Py_RETURN_NONE;

}

return obj;

}

static Py_hash_t

weakref_hash_lock_held(PyWeakReference *self)

{

if (self->hash != -1)

return self->hash;

PyObject* obj = _PyWeakref_GET_REF((PyObject*)self);

if (obj == NULL) {

PyErr_SetString(PyExc_TypeError, "weak object has gone away");

return -1;

}

self->hash = PyObject_Hash(obj);

Py_DECREF(obj);

return self->hash;

}

static Py_hash_t

weakref_hash(PyWeakReference *self)

{

Py_hash_t hash;

Py_BEGIN_CRITICAL_SECTION(self);

hash = weakref_hash_lock_held(self);

Py_END_CRITICAL_SECTION();

return hash;

}

static PyObject *

weakref_repr(PyObject *self)

{

PyObject* obj = _PyWeakref_GET_REF(self);

if (obj == NULL) {

return PyUnicode_FromFormat("<weakref at %p; dead>", self);

}

PyObject *name = _PyObject_LookupSpecial(obj, &_Py_ID(__name__));

PyObject *repr;

if (name == NULL || !PyUnicode_Check(name)) {

repr = PyUnicode_FromFormat(

"<weakref at %p; to '%T' at %p>",

self, obj, obj);

}

else {

repr = PyUnicode_FromFormat(

"<weakref at %p; to '%T' at %p (%U)>",

self, obj, obj, name);

}

Py_DECREF(obj);

Py_XDECREF(name);

return repr;

}

static PyObject *

weakref_richcompare(PyObject* self, PyObject* other, int op)

{

if ((op != Py_EQ && op != Py_NE) ||

!PyWeakref_Check(self) ||

!PyWeakref_Check(other)) {

Py_RETURN_NOTIMPLEMENTED;

}

PyObject* obj = _PyWeakref_GET_REF(self);

PyObject* other_obj = _PyWeakref_GET_REF(other);

if (obj == NULL || other_obj == NULL) {

Py_XDECREF(obj);

Py_XDECREF(other_obj);

int res = (self == other);

if (op == Py_NE)

res = !res;

if (res)

Py_RETURN_TRUE;

else

Py_RETURN_FALSE;

}

PyObject* res = PyObject_RichCompare(obj, other_obj, op);

Py_DECREF(obj);

Py_DECREF(other_obj);

return res;

}

static void

get_basic_refs(PyWeakReference *head,

PyWeakReference **refp, PyWeakReference **proxyp)

{

*refp = NULL;

*proxyp = NULL;

if (head != NULL && head->wr_callback == NULL) {

/* We need to be careful that the "basic refs" aren't

if (PyWeakref_CheckRefExact(head)) {

*refp = head;

head = head->wr_next;

}

if (head != NULL

&& head->wr_callback == NULL

&& PyWeakref_CheckProxy(head)) {

*proxyp = head;

/* head = head->wr_next; */

}

}

}

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;

}

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 PyWeakReference *

try_reuse_basic_ref(PyWeakReference *list, PyTypeObject *type,

PyObject *callback)

{

if (callback != NULL) {

return NULL;

}

PyWeakReference *ref, *proxy;

get_basic_refs(list, &ref, &proxy);

PyWeakReference *cand = NULL;

if (type == &_PyWeakref_RefType) {

cand = ref;

}

if ((type == &_PyWeakref_ProxyType) ||

(type == &_PyWeakref_CallableProxyType)) {

cand = proxy;

}

if (cand != NULL && _Py_TryIncref((PyObject *) cand)) {

return cand;

}

return NULL;

}

static int

is_basic_ref(PyWeakReference *ref)

{

return (ref->wr_callback == NULL) && PyWeakref_CheckRefExact(ref);

}

static int

is_basic_proxy(PyWeakReference *proxy)

{

return (proxy->wr_callback == NULL) && PyWeakref_CheckProxy(proxy);

}

static int

is_basic_ref_or_proxy(PyWeakReference *wr)

{

return is_basic_ref(wr) || is_basic_proxy(wr);

}

static void

insert_weakref(PyWeakReference *newref, PyWeakReference **list)

{

PyWeakReference *ref, *proxy;

get_basic_refs(*list, &ref, &proxy);

PyWeakReference *prev;

if (is_basic_ref(newref)) {

prev = NULL;

}

else if (is_basic_proxy(newref)) {

prev = ref;

}

else {

prev = (proxy == NULL) ? ref : proxy;

}

if (prev == NULL) {

insert_head(newref, list);

}

else {

insert_after(newref, prev);

}

}

static PyWeakReference *

allocate_weakref(PyTypeObject *type, PyObject *obj, PyObject *callback)

{

PyWeakReference *newref = (PyWeakReference *) type->tp_alloc(type, 0);

if (newref == NULL) {

return NULL;

}

init_weakref(newref, obj, callback);

return newref;

}

static PyWeakReference *

get_or_create_weakref(PyTypeObject *type, PyObject *obj, PyObject *callback)

{

if (!_PyType_SUPPORTS_WEAKREFS(Py_TYPE(obj))) {

PyErr_Format(PyExc_TypeError,

"cannot create weak reference to '%s' object",

Py_TYPE(obj)->tp_name);

return NULL;

}

if (callback == Py_None)

callback = NULL;

PyWeakReference **list = GET_WEAKREFS_LISTPTR(obj);

if ((type == &_PyWeakref_RefType) ||

(type == &_PyWeakref_ProxyType) ||

(type == &_PyWeakref_CallableProxyType))

{

LOCK_WEAKREFS(obj);

PyWeakReference *basic_ref = try_reuse_basic_ref(*list, type, callback);

if (basic_ref != NULL) {

UNLOCK_WEAKREFS(obj);

return basic_ref;

}

PyWeakReference *newref = allocate_weakref(type, obj, callback);

if (newref == NULL) {

UNLOCK_WEAKREFS(obj);

return NULL;

}

insert_weakref(newref, list);

UNLOCK_WEAKREFS(obj);

return newref;

}

else {

// We may not be able to safely allocate inside the lock

PyWeakReference *newref = allocate_weakref(type, obj, callback);

if (newref == NULL) {

return NULL;

}

LOCK_WEAKREFS(obj);

insert_weakref(newref, list);

UNLOCK_WEAKREFS(obj);

return newref;

}

}

static int

parse_weakref_init_args(const char *funcname, PyObject *args, PyObject *kwargs,

PyObject **obp, PyObject **callbackp)

{

return PyArg_UnpackTuple(args, funcname, 1, 2, obp, callbackp);

}

static PyObject *

weakref___new__(PyTypeObject *type, PyObject *args, PyObject *kwargs)

{

PyObject *ob, *callback = NULL;

if (parse_weakref_init_args("__new__", args, kwargs, &ob, &callback)) {

return (PyObject *)get_or_create_weakref(type, ob, callback);

}

return NULL;

}

static int

weakref___init__(PyObject *self, PyObject *args, PyObject *kwargs)

{

PyObject *tmp;

if (!_PyArg_NoKeywords("ref", kwargs))

return -1;

if (parse_weakref_init_args("__init__", args, kwargs, &tmp, &tmp))

return 0;

else

return -1;

}

static PyMemberDef weakref_members[] = {

{"__callback__", _Py_T_OBJECT, offsetof(PyWeakReference, wr_callback), Py_READONLY},

{NULL} /* Sentinel */

};

static PyMethodDef weakref_methods[] = {

{"__class_getitem__", Py_GenericAlias,

METH_O|METH_CLASS, PyDoc_STR("See PEP 585")},

{NULL} /* Sentinel */

};

_PyWeakref_RefType = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

.tp_name = "weakref.ReferenceType",

.tp_basicsize = sizeof(PyWeakReference),

.tp_dealloc = weakref_dealloc,

.tp_vectorcall_offset = offsetof(PyWeakReference, vectorcall),

.tp_call = PyVectorcall_Call,

.tp_repr = weakref_repr,

.tp_hash = (hashfunc)weakref_hash,

.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |

Py_TPFLAGS_HAVE_VECTORCALL | Py_TPFLAGS_BASETYPE,

.tp_traverse = (traverseproc)gc_traverse,

.tp_clear = (inquiry)gc_clear,

.tp_richcompare = weakref_richcompare,

.tp_methods = weakref_methods,

.tp_members = weakref_members,

.tp_init = weakref___init__,

.tp_alloc = PyType_GenericAlloc,

.tp_new = weakref___new__,

.tp_free = PyObject_GC_Del,

};

static bool

proxy_check_ref(PyObject *obj)

{

if (obj == NULL) {

PyErr_SetString(PyExc_ReferenceError,

"weakly-referenced object no longer exists");

return false;

}

return true;

}

#define UNWRAP(o) \

if (PyWeakref_CheckProxy(o)) { \

o = _PyWeakref_GET_REF(o); \

if (!proxy_check_ref(o)) { \

return NULL; \

} \

} \

else { \

Py_INCREF(o); \

}

#define WRAP_UNARY(method, generic) \

static PyObject * \

method(PyObject *proxy) { \

UNWRAP(proxy); \

PyObject* res = generic(proxy); \

Py_DECREF(proxy); \

return res; \

}

#define WRAP_BINARY(method, generic) \

static PyObject * \

method(PyObject *x, PyObject *y) { \

UNWRAP(x); \

UNWRAP(y); \

PyObject* res = generic(x, y); \

Py_DECREF(x); \

Py_DECREF(y); \

return res; \

}

#define WRAP_TERNARY(method, generic) \

static PyObject * \

method(PyObject *proxy, PyObject *v, PyObject *w) { \

UNWRAP(proxy); \

UNWRAP(v); \

if (w != NULL) { \

UNWRAP(w); \

} \

PyObject* res = generic(proxy, v, w); \

Py_DECREF(proxy); \

Py_DECREF(v); \

Py_XDECREF(w); \

return res; \

}

#define WRAP_METHOD(method, SPECIAL) \

static PyObject * \

method(PyObject *proxy, PyObject *Py_UNUSED(ignored)) { \

UNWRAP(proxy); \

PyObject* res = PyObject_CallMethodNoArgs(proxy, &_Py_ID(SPECIAL)); \

Py_DECREF(proxy); \

return res; \

}

WRAP_BINARY(proxy_getattr, PyObject_GetAttr)

WRAP_UNARY(proxy_str, PyObject_Str)

WRAP_TERNARY(proxy_call, PyObject_Call)

static PyObject *

proxy_repr(PyObject *proxy)

{

PyObject *obj = _PyWeakref_GET_REF(proxy);

PyObject *repr;

if (obj != NULL) {

repr = PyUnicode_FromFormat(

"<weakproxy at %p; to '%T' at %p>",

proxy, obj, obj);

Py_DECREF(obj);

}

else {

repr = PyUnicode_FromFormat(

"<weakproxy at %p; dead>",

proxy);

}

return repr;

}

static int

proxy_setattr(PyObject *proxy, PyObject *name, PyObject *value)

{

PyObject *obj = _PyWeakref_GET_REF(proxy);

if (!proxy_check_ref(obj)) {

return -1;

}

int res = PyObject_SetAttr(obj, name, value);

Py_DECREF(obj);

return res;

}

static PyObject *

proxy_richcompare(PyObject *proxy, PyObject *v, int op)

{

UNWRAP(proxy);

UNWRAP(v);

PyObject* res = PyObject_RichCompare(proxy, v, op);

Py_DECREF(proxy);

Py_DECREF(v);

return res;

}

WRAP_BINARY(proxy_add, PyNumber_Add)

WRAP_BINARY(proxy_sub, PyNumber_Subtract)

WRAP_BINARY(proxy_mul, PyNumber_Multiply)

WRAP_BINARY(proxy_floor_div, PyNumber_FloorDivide)

WRAP_BINARY(proxy_true_div, PyNumber_TrueDivide)

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_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_ifloor_div, PyNumber_InPlaceFloorDivide)

WRAP_BINARY(proxy_itrue_div, PyNumber_InPlaceTrueDivide)

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)

WRAP_UNARY(proxy_index, PyNumber_Index)

WRAP_BINARY(proxy_matmul, PyNumber_MatrixMultiply)

WRAP_BINARY(proxy_imatmul, PyNumber_InPlaceMatrixMultiply)

static int

proxy_bool(PyObject *proxy)

{

PyObject *o = _PyWeakref_GET_REF(proxy);

if (!proxy_check_ref(o)) {

return -1;

}

int res = PyObject_IsTrue(o);

Py_DECREF(o);

return res;

}

static void

proxy_dealloc(PyWeakReference *self)

{

PyObject_GC_UnTrack(self);

clear_weakref(self);

PyObject_GC_Del(self);

}

static int

proxy_contains(PyObject *proxy, PyObject *value)

{

PyObject *obj = _PyWeakref_GET_REF(proxy);

if (!proxy_check_ref(obj)) {

return -1;

}

int res = PySequence_Contains(obj, value);

Py_DECREF(obj);

return res;

}

static Py_ssize_t

proxy_length(PyObject *proxy)

{

PyObject *obj = _PyWeakref_GET_REF(proxy);

if (!proxy_check_ref(obj)) {

return -1;

}

Py_ssize_t res = PyObject_Length(obj);

Py_DECREF(obj);

return res;

}

WRAP_BINARY(proxy_getitem, PyObject_GetItem)

static int

proxy_setitem(PyObject *proxy, PyObject *key, PyObject *value)

{

PyObject *obj = _PyWeakref_GET_REF(proxy);

if (!proxy_check_ref(obj)) {

return -1;

}

int res;

if (value == NULL) {

res = PyObject_DelItem(obj, key);

} else {

res = PyObject_SetItem(obj, key, value);

}

Py_DECREF(obj);

return res;

}

static PyObject *

proxy_iter(PyObject *proxy)

{

PyObject *obj = _PyWeakref_GET_REF(proxy);

if (!proxy_check_ref(obj)) {

return NULL;

}

PyObject* res = PyObject_GetIter(obj);

Py_DECREF(obj);

return res;

}

static PyObject *

proxy_iternext(PyObject *proxy)

{

PyObject *obj = _PyWeakref_GET_REF(proxy);

if (!proxy_check_ref(obj)) {

return NULL;

}

if (!PyIter_Check(obj)) {

PyErr_Format(PyExc_TypeError,

"Weakref proxy referenced a non-iterator '%.200s' object",

Py_TYPE(obj)->tp_name);

Py_DECREF(obj);

return NULL;

}

PyObject* res = PyIter_Next(obj);

Py_DECREF(obj);

return res;

}

WRAP_METHOD(proxy_bytes, __bytes__)

WRAP_METHOD(proxy_reversed, __reversed__)

static PyMethodDef proxy_methods[] = {

{"__bytes__", proxy_bytes, METH_NOARGS},

{"__reversed__", proxy_reversed, METH_NOARGS},

{NULL, NULL}

};

static PyNumberMethods proxy_as_number = {

proxy_add, /*nb_add*/

proxy_sub, /*nb_subtract*/

proxy_mul, /*nb_multiply*/

proxy_mod, /*nb_remainder*/

proxy_divmod, /*nb_divmod*/

proxy_pow, /*nb_power*/

proxy_neg, /*nb_negative*/

proxy_pos, /*nb_positive*/

proxy_abs, /*nb_absolute*/

proxy_bool, /*nb_bool*/

proxy_invert, /*nb_invert*/

proxy_lshift, /*nb_lshift*/

proxy_rshift, /*nb_rshift*/

proxy_and, /*nb_and*/

proxy_xor, /*nb_xor*/

proxy_or, /*nb_or*/

proxy_int, /*nb_int*/

0, /*nb_reserved*/

proxy_float, /*nb_float*/

proxy_iadd, /*nb_inplace_add*/

proxy_isub, /*nb_inplace_subtract*/

proxy_imul, /*nb_inplace_multiply*/

proxy_imod, /*nb_inplace_remainder*/

proxy_ipow, /*nb_inplace_power*/

proxy_ilshift, /*nb_inplace_lshift*/

proxy_irshift, /*nb_inplace_rshift*/

proxy_iand, /*nb_inplace_and*/

proxy_ixor, /*nb_inplace_xor*/

proxy_ior, /*nb_inplace_or*/

proxy_floor_div, /*nb_floor_divide*/

proxy_true_div, /*nb_true_divide*/

proxy_ifloor_div, /*nb_inplace_floor_divide*/

proxy_itrue_div, /*nb_inplace_true_divide*/

proxy_index, /*nb_index*/

proxy_matmul, /*nb_matrix_multiply*/

proxy_imatmul, /*nb_inplace_matrix_multiply*/

};

static PySequenceMethods proxy_as_sequence = {

proxy_length, /*sq_length*/

0, /*sq_concat*/

0, /*sq_repeat*/

0, /*sq_item*/

0, /*sq_slice*/

0, /*sq_ass_item*/

0, /*sq_ass_slice*/

proxy_contains, /* sq_contains */

};

static PyMappingMethods proxy_as_mapping = {

proxy_length, /*mp_length*/

proxy_getitem, /*mp_subscript*/

proxy_setitem, /*mp_ass_subscript*/

};

_PyWeakref_ProxyType = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"weakref.ProxyType",

sizeof(PyWeakReference),

0,

/* methods */

(destructor)proxy_dealloc, /* tp_dealloc */

0, /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

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 */

0, /* tp_call */

proxy_str, /* tp_str */

proxy_getattr, /* tp_getattro */

proxy_setattr, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */

0, /* tp_doc */

(traverseproc)gc_traverse, /* tp_traverse */

(inquiry)gc_clear, /* tp_clear */

proxy_richcompare, /* tp_richcompare */

0, /* tp_weaklistoffset */

proxy_iter, /* tp_iter */

proxy_iternext, /* tp_iternext */

proxy_methods, /* tp_methods */

};

_PyWeakref_CallableProxyType = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"weakref.CallableProxyType",

sizeof(PyWeakReference),

0,

/* methods */

(destructor)proxy_dealloc, /* tp_dealloc */

0, /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

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 */

proxy_call, /* tp_call */

proxy_str, /* tp_str */

proxy_getattr, /* tp_getattro */

proxy_setattr, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */

0, /* tp_doc */

(traverseproc)gc_traverse, /* tp_traverse */

(inquiry)gc_clear, /* tp_clear */

proxy_richcompare, /* tp_richcompare */

0, /* tp_weaklistoffset */

proxy_iter, /* tp_iter */

proxy_iternext, /* tp_iternext */

};

PyObject *

PyWeakref_NewRef(PyObject *ob, PyObject *callback)

{

return (PyObject *)get_or_create_weakref(&_PyWeakref_RefType, ob,

callback);

}

PyObject *

PyWeakref_NewProxy(PyObject *ob, PyObject *callback)

{

PyTypeObject *type = &_PyWeakref_ProxyType;

if (PyCallable_Check(ob)) {

type = &_PyWeakref_CallableProxyType;

}

return (PyObject *)get_or_create_weakref(type, ob, callback);

}

PyWeakref_GetRef(PyObject *ref, PyObject **pobj)

{

if (ref == NULL) {

*pobj = NULL;

PyErr_BadInternalCall();

return -1;

}

if (!PyWeakref_Check(ref)) {

*pobj = NULL;

PyErr_SetString(PyExc_TypeError, "expected a weakref");

return -1;

}

*pobj = _PyWeakref_GET_REF(ref);

return (*pobj != NULL);

}

PyObject *

PyWeakref_GetObject(PyObject *ref)

{

if (ref == NULL || !PyWeakref_Check(ref)) {

PyErr_BadInternalCall();

return NULL;

}

PyObject *obj = _PyWeakref_GET_REF(ref);

if (obj == NULL) {

return Py_None;

}

Py_DECREF(obj);

return obj; // borrowed reference

}

static void

handle_callback(PyWeakReference *ref, PyObject *callback)

{

PyObject *cbresult = PyObject_CallOneArg(callback, (PyObject *)ref);

if (cbresult == NULL)

PyErr_WriteUnraisable(callback);

else

Py_DECREF(cbresult);

}

PyObject_ClearWeakRefs(PyObject *object)

{

PyWeakReference **list;

if (object == NULL

|| !_PyType_SUPPORTS_WEAKREFS(Py_TYPE(object))

|| Py_REFCNT(object) != 0)

{

PyErr_BadInternalCall();

return;

}

list = GET_WEAKREFS_LISTPTR(object);

if (FT_ATOMIC_LOAD_PTR(*list) == NULL) {

// Fast path for the common case

return;