Replaced _zope_proxy_proxy.c with a new version.

This one comes from zope.proxy commit 2938c335, version 4.1.2dev.

src/zope/container/_zope_proxy_proxy.c

@@ -14,7 +14,7 @@
 
 /*
  *   This file is also used as a really extensive macro in
- *   ../app/container/_zope_container_contained.c.  If you need to
+ *   ../container/_zope_container_contained.c.  If you need to
  *   change this file, you need to "svn copy" it to ../container/.
  *
  *   This approach is taken to allow the sources for the two packages
@@ -28,7 +28,7 @@
 #include "modsupport.h"
 
 #define PROXY_MODULE
-#include "zope.proxy/proxy.h"
+#include "proxy.h"
 
 static PyTypeObject ProxyType;
 
@@ -38,6 +38,47 @@ static PyObject *
 empty_tuple = NULL;
 
 
+#if PY_VERSION_HEX <  0x02070000
+  #define PyCapsule_New(pointer, name, destr) \
+          PyCObject_FromVoidPtr(pointer, destr)
+#endif
+
+// Compatibility with Python 2
+#if PY_MAJOR_VERSION < 3
+  #define IS_STRING PyString_Check
+
+  #define MAKE_STRING(name) PyString_AS_STRING(name)
+
+  #define MOD_ERROR_VAL
+
+  #define MOD_SUCCESS_VAL(val)
+
+  #define MOD_INIT(name) void init##name(void)
+
+  #define MOD_DEF(ob, name, doc, methods) \
+          ob = Py_InitModule3(name, methods, doc);
+
+#else
+
+  #define IS_STRING PyUnicode_Check
+
+  #define MAKE_STRING(name) PyBytes_AS_STRING( \
+          PyUnicode_AsUTF8String(name))
+
+  #define MOD_ERROR_VAL NULL
+
+  #define MOD_SUCCESS_VAL(val) val
+
+  #define MOD_INIT(name) PyMODINIT_FUNC PyInit_##name(void)
+
+  #define MOD_DEF(ob, name, doc, methods) \
+          static struct PyModuleDef moduledef = { \
+            PyModuleDef_HEAD_INIT, name, doc, -1, methods, }; \
+          ob = PyModule_Create(&moduledef);
+#endif
+
+
+
 /*
  *   Slot methods.
  */
@@ -166,19 +207,23 @@ WrapperType_Lookup(PyTypeObject *type, PyObject *name)
 
     assert(PyTuple_Check(mro));
 
-    n = PyTuple_GET_SIZE(mro) 
+    n = PyTuple_GET_SIZE(mro)
       - 1; /* We don't want to look at the last item, which is object. */
 
     for (i = 0; i < n; i++) {
         base = PyTuple_GET_ITEM(mro, i);
 
         if (((PyTypeObject *)base) != &ProxyType) {
+#if PY_MAJOR_VERSION < 3
             if (PyClass_Check(base))
                 dict = ((PyClassObject *)base)->cl_dict;
-            else {
+            else
+#endif
+            {
                 assert(PyType_Check(base));
                 dict = ((PyTypeObject *)base)->tp_dict;
             }
+
             assert(dict && PyDict_Check(dict));
             res = PyDict_GetItem(dict, name);
             if (res != NULL)
@@ -195,13 +240,13 @@ wrap_getattro(PyObject *self, PyObject *name)
     PyObject *wrapped;
     PyObject *descriptor;
     PyObject *res = NULL;
-    char *name_as_string;
+    const char *name_as_string;
     int maybe_special_name;
 
-#ifdef Py_USING_UNICODE
+#if PY_MAJOR_VERSION < 3 && defined(Py_USING_UNICODE)
     /* The Unicode to string conversion is done here because the
-       existing tp_getattro slots expect a string object as name
-       and we wouldn't want to break those. */
+       existing tp_setattro slots expect a string object as name
+       (except under Python 3) and we wouldn't want to break those. */
     if (PyUnicode_Check(name)) {
         name = PyUnicode_AsEncodedString(name, NULL, NULL);
         if (name == NULL)
@@ -209,14 +254,16 @@ wrap_getattro(PyObject *self, PyObject *name)
     }
     else
 #endif
-    if (!PyString_Check(name)){
+
+    if (!IS_STRING(name)){
         PyErr_SetString(PyExc_TypeError, "attribute name must be string");
         return NULL;
     }
     else
         Py_INCREF(name);
 
-    name_as_string = PyString_AS_STRING(name);
+    name_as_string = MAKE_STRING(name);
+
     wrapped = Proxy_GET_OBJECT(self);
     if (wrapped == NULL) {
         PyErr_Format(PyExc_RuntimeError,
@@ -232,16 +279,33 @@ wrap_getattro(PyObject *self, PyObject *name)
         descriptor = WrapperType_Lookup(self->ob_type, name);
 
         if (descriptor != NULL) {
-            if (PyType_HasFeature(descriptor->ob_type, Py_TPFLAGS_HAVE_CLASS)
-                && descriptor->ob_type->tp_descr_get != NULL) {
+            if (descriptor->ob_type->tp_descr_get != NULL
+#if PY_MAJOR_VERSION < 3 // Always true in Python 3
+                && PyType_HasFeature(descriptor->ob_type, Py_TPFLAGS_HAVE_CLASS)
+#endif
+            ){
+              if (descriptor->ob_type->tp_descr_set == NULL)
+                {
+                  res = PyObject_GetAttr(wrapped, name);
+                  if (res != NULL)
+                    goto finally;
+                  if (PyErr_ExceptionMatches(PyExc_AttributeError))
+                    PyErr_Clear();
+                  else
+                    goto finally;
+                }
+
                 res = descriptor->ob_type->tp_descr_get(
                         descriptor,
                         self,
                         (PyObject *)self->ob_type);
-            } else {
+            }
+            else
+            {
                 Py_INCREF(descriptor);
                 res = descriptor;
             }
+
             goto finally;
         }
     }
@@ -257,12 +321,14 @@ wrap_setattro(PyObject *self, PyObject *name, PyObject *value)
 {
     PyObject *wrapped;
     PyObject *descriptor;
+    const char *name_as_string;
     int res = -1;
 
-#ifdef Py_USING_UNICODE
+#if PY_MAJOR_VERSION < 3 && defined(Py_USING_UNICODE)
     /* The Unicode to string conversion is done here because the
        existing tp_setattro slots expect a string object as name
-       and we wouldn't want to break those. */
+       (except under Python 3) and we wouldn't want to break those. */
+
     if (PyUnicode_Check(name)) {
         name = PyUnicode_AsEncodedString(name, NULL, NULL);
         if (name == NULL)
@@ -270,7 +336,8 @@ wrap_setattro(PyObject *self, PyObject *name, PyObject *value)
     }
     else
 #endif
-    if (!PyString_Check(name)){
+
+    if (!IS_STRING(name)){
         PyErr_SetString(PyExc_TypeError, "attribute name must be string");
         return -1;
     }
@@ -278,23 +345,24 @@ wrap_setattro(PyObject *self, PyObject *name, PyObject *value)
         Py_INCREF(name);
 
     descriptor = WrapperType_Lookup(self->ob_type, name);
-    if (descriptor != NULL) {
-        if (PyType_HasFeature(descriptor->ob_type, Py_TPFLAGS_HAVE_CLASS) &&
-            descriptor->ob_type->tp_descr_set != NULL) {
-            res = descriptor->ob_type->tp_descr_set(descriptor, self, value);
-        } else {
-            PyErr_Format(PyExc_TypeError,
-                "Tried to set attribute '%s' on wrapper, but it is not"
-                " a data descriptor", PyString_AS_STRING(name));
-        }
+
+    if (descriptor != NULL
+#if PY_MAJOR_VERSION < 3 // This is always true in Python 3 (I think)
+        && PyType_HasFeature(descriptor->ob_type, Py_TPFLAGS_HAVE_CLASS)
+#endif
+        && descriptor->ob_type->tp_descr_set != NULL)
+      {
+        res = descriptor->ob_type->tp_descr_set(descriptor, self, value);
         goto finally;
-    }
+      }
+
+    name_as_string = MAKE_STRING(name);
 
     wrapped = Proxy_GET_OBJECT(self);
     if (wrapped == NULL) {
         PyErr_Format(PyExc_RuntimeError,
             "object is NULL; requested to set attribute '%s'",
-            PyString_AS_STRING(name));
+            name_as_string);
         goto finally;
     }
     res = PyObject_SetAttr(wrapped, name, value);
@@ -321,12 +389,13 @@ wrap_repr(PyObject *wrapper)
     return PyObject_Repr(Proxy_GET_OBJECT(wrapper));
 }
 
-
+#if PY_MAJOR_VERSION < 3
 static int
 wrap_compare(PyObject *wrapper, PyObject *v)
 {
     return PyObject_Compare(Proxy_GET_OBJECT(wrapper), v);
 }
+#endif
 
 static long
 wrap_hash(PyObject *self)
@@ -339,15 +408,11 @@ wrap_call(PyObject *self, PyObject *args, PyObject *kw)
 {
     if (kw)
         return PyEval_CallObjectWithKeywords(Proxy_GET_OBJECT(self),
-					     args, kw);
+                                             args, kw);
     else
         return PyObject_CallObject(Proxy_GET_OBJECT(self), args);
 }
 
-/*
- *   Number methods
- */
-
 /*
  * Number methods.
  */
@@ -364,6 +429,7 @@ call_int(PyObject *self)
     return nb->nb_int(self);
 }
 
+#if PY_MAJOR_VERSION < 3 // Python 3 has no long, oct or hex methods.
 static PyObject *
 call_long(PyObject *self)
 {
@@ -376,18 +442,6 @@ call_long(PyObject *self)
     return nb->nb_long(self);
 }
 
-static PyObject *
-call_float(PyObject *self)
-{
-    PyNumberMethods *nb = self->ob_type->tp_as_number;
-    if (nb == NULL || nb->nb_float== NULL) {
-        PyErr_SetString(PyExc_TypeError,
-                        "object can't be converted to float");
-        return NULL;
-    }
-    return nb->nb_float(self);
-}
-
 static PyObject *
 call_oct(PyObject *self)
 {
@@ -412,6 +466,32 @@ call_hex(PyObject *self)
     return nb->nb_hex(self);
 }
 
+#endif
+
+static PyObject *
+call_index(PyObject *self)
+{
+    PyNumberMethods *nb = self->ob_type->tp_as_number;
+    if (nb == NULL || nb->nb_index == NULL) {
+        PyErr_SetString(PyExc_TypeError,
+                        "object can't be converted to index");
+        return NULL;
+    }
+    return nb->nb_index(self);
+}
+
+static PyObject *
+call_float(PyObject *self)
+{
+    PyNumberMethods *nb = self->ob_type->tp_as_number;
+    if (nb == NULL || nb->nb_float== NULL) {
+        PyErr_SetString(PyExc_TypeError,
+                        "object can't be converted to float");
+        return NULL;
+    }
+    return nb->nb_float(self);
+}
+
 static PyObject *
 call_ipow(PyObject *self, PyObject *other)
 {
@@ -464,10 +544,10 @@ check2(PyObject *self, PyObject *other,
 
 static PyObject *
 check2i(ProxyObject *self, PyObject *other,
-	char *opname, binaryfunc operation)
+        char *opname, binaryfunc operation)
 {
-	PyObject *result = NULL;
-	PyObject *object = Proxy_GET_OBJECT(self);
+        PyObject *result = NULL;
+        PyObject *object = Proxy_GET_OBJECT(self);
 
         result = operation(object, other);
         if (result == object) {
@@ -482,25 +562,27 @@ check2i(ProxyObject *self, PyObject *other,
             /* ??? create proxy for result? */
             ;
 #endif
-	return result;
+        return result;
 }
 
 #define UNOP(NAME, CALL) \
-	static PyObject *wrap_##NAME(PyObject *self) \
-	{ return check1((ProxyObject *)self, "__"#NAME"__", CALL); }
+        static PyObject *wrap_##NAME(PyObject *self) \
+        { return check1((ProxyObject *)self, "__"#NAME"__", CALL); }
 
 #define BINOP(NAME, CALL) \
-	static PyObject *wrap_##NAME(PyObject *self, PyObject *other) \
-	{ return check2(self, other, "__"#NAME"__", "__r"#NAME"__", CALL); }
+        static PyObject *wrap_##NAME(PyObject *self, PyObject *other) \
+        { return check2(self, other, "__"#NAME"__", "__r"#NAME"__", CALL); }
 
 #define INPLACE(NAME, CALL) \
-	static PyObject *wrap_i##NAME(PyObject *self, PyObject *other) \
-	{ return check2i((ProxyObject *)self, other, "__i"#NAME"__", CALL); }
+        static PyObject *wrap_i##NAME(PyObject *self, PyObject *other) \
+        { return check2i((ProxyObject *)self, other, "__i"#NAME"__", CALL); }
 
 BINOP(add, PyNumber_Add)
 BINOP(sub, PyNumber_Subtract)
 BINOP(mul, PyNumber_Multiply)
+#if PY_MAJOR_VERSION < 3 // Python 3 doesn't support the old integer division
 BINOP(div, PyNumber_Divide)
+#endif
 BINOP(mod, PyNumber_Remainder)
 BINOP(divmod, PyNumber_Divmod)
 
@@ -535,6 +617,7 @@ BINOP(and, PyNumber_And)
 BINOP(xor, PyNumber_Xor)
 BINOP(or, PyNumber_Or)
 
+#if PY_MAJOR_VERSION < 3 // Coercion is gone in Python 3
 static int
 wrap_coerce(PyObject **p_self, PyObject **p_other)
 {
@@ -573,6 +656,7 @@ wrap_coerce(PyObject **p_self, PyObject **p_other)
     *p_other = right;
     return 0;
 }
+#endif
 
 UNOP(neg, PyNumber_Negative)
 UNOP(pos, PyNumber_Positive)
@@ -580,15 +664,19 @@ UNOP(abs, PyNumber_Absolute)
 UNOP(invert, PyNumber_Invert)
 
 UNOP(int, call_int)
-UNOP(long, call_long)
 UNOP(float, call_float)
+#if PY_MAJOR_VERSION < 3 // Python 3 has no long, oct or hex methods
+UNOP(long, call_long)
 UNOP(oct, call_oct)
 UNOP(hex, call_hex)
+#endif
 
 INPLACE(add, PyNumber_InPlaceAdd)
 INPLACE(sub, PyNumber_InPlaceSubtract)
 INPLACE(mul, PyNumber_InPlaceMultiply)
+#if PY_MAJOR_VERSION < 3 // The old integer division operator is gone in Python 3
 INPLACE(div, PyNumber_InPlaceDivide)
+#endif
 INPLACE(mod, PyNumber_InPlaceRemainder)
 INPLACE(pow, call_ipow)
 INPLACE(lshift, PyNumber_InPlaceLshift)
@@ -601,6 +689,7 @@ BINOP(floordiv, PyNumber_FloorDivide)
 BINOP(truediv, PyNumber_TrueDivide)
 INPLACE(floordiv, PyNumber_InPlaceFloorDivide)
 INPLACE(truediv, PyNumber_InPlaceTrueDivide)
+UNOP(index, call_index)
 
 static int
 wrap_nonzero(PyObject *self)
@@ -621,13 +710,28 @@ wrap_length(PyObject *self)
 static PyObject *
 wrap_slice(PyObject *self, Py_ssize_t start, Py_ssize_t end)
 {
-    return PySequence_GetSlice(Proxy_GET_OBJECT(self), start, end);
+    PyObject *obj = Proxy_GET_OBJECT(self);
+    if (PyList_Check(obj)) {
+        return PyList_GetSlice(obj, start, end);
+    }
+    else if (PyTuple_Check(obj)) {
+        return PyTuple_GetSlice(obj, start, end);
+    }
+    else {
+        return PySequence_GetSlice(obj, start, end);
+    }
 }
 
 static int
 wrap_ass_slice(PyObject *self, Py_ssize_t i, Py_ssize_t j, PyObject *value)
 {
-    return PySequence_SetSlice(Proxy_GET_OBJECT(self), i, j, value);
+    PyObject *obj = Proxy_GET_OBJECT(self);
+    if (PyList_Check(obj)) {
+        return PyList_SetSlice(obj, i, j, value);
+    }
+    else {
+        return PySequence_SetSlice(obj, i, j, value);
+    }
 }
 
 static int
@@ -649,9 +753,9 @@ static int
 wrap_setitem(PyObject *self, PyObject *key, PyObject *value)
 {
     if (value == NULL)
-	return PyObject_DelItem(Proxy_GET_OBJECT(self), key);
+        return PyObject_DelItem(Proxy_GET_OBJECT(self), key);
     else
-	return PyObject_SetItem(Proxy_GET_OBJECT(self), key, value);
+        return PyObject_SetItem(Proxy_GET_OBJECT(self), key, value);
 }
 
 /*
@@ -689,69 +793,82 @@ wrap_reduce(PyObject *self)
 
 static PyNumberMethods
 wrap_as_number = {
-    wrap_add,				/* nb_add */
-    wrap_sub,				/* nb_subtract */
-    wrap_mul,				/* nb_multiply */
-    wrap_div,				/* nb_divide */
-    wrap_mod,				/* nb_remainder */
-    wrap_divmod,			/* nb_divmod */
-    wrap_pow,				/* nb_power */
-    wrap_neg,				/* nb_negative */
-    wrap_pos,				/* nb_positive */
-    wrap_abs,				/* nb_absolute */
-    wrap_nonzero,			/* nb_nonzero */
-    wrap_invert,			/* nb_invert */
-    wrap_lshift,			/* nb_lshift */
-    wrap_rshift,			/* nb_rshift */
-    wrap_and,				/* nb_and */
-    wrap_xor,				/* nb_xor */
-    wrap_or,				/* nb_or */
-    wrap_coerce,			/* nb_coerce */
-    wrap_int,				/* nb_int */
-    wrap_long,				/* nb_long */
-    wrap_float,				/* nb_float */
-    wrap_oct,				/* nb_oct */
-    wrap_hex,				/* nb_hex */
+    wrap_add,                               /* nb_add */
+    wrap_sub,                               /* nb_subtract */
+    wrap_mul,                               /* nb_multiply */
+#if PY_MAJOR_VERSION < 3
+    wrap_div,                               /* nb_divide */
+#endif
+    wrap_mod,                               /* nb_remainder */
+    wrap_divmod,                            /* nb_divmod */
+    wrap_pow,                               /* nb_power */
+    wrap_neg,                               /* nb_negative */
+    wrap_pos,                               /* nb_positive */
+    wrap_abs,                               /* nb_absolute */
+    wrap_nonzero,                           /* nb_nonzero */
+    wrap_invert,                            /* nb_invert */
+    wrap_lshift,                            /* nb_lshift */
+    wrap_rshift,                            /* nb_rshift */
+    wrap_and,                               /* nb_and */
+    wrap_xor,                               /* nb_xor */
+    wrap_or,                                /* nb_or */
+#if PY_MAJOR_VERSION < 3
+    wrap_coerce,                            /* nb_coerce */
+#endif
+    wrap_int,                               /* nb_int */
+#if PY_MAJOR_VERSION < 3
+    wrap_long,                              /* nb_long */
+#else
+    0,                                      /* formerly known as nb_long */
+#endif
+    wrap_float,                             /* nb_float */
+#if PY_MAJOR_VERSION < 3
+    wrap_oct,                               /* nb_oct */
+    wrap_hex,                               /* nb_hex */
+#endif
 
     /* Added in release 2.0 */
     /* These require the Py_TPFLAGS_HAVE_INPLACEOPS flag */
-    wrap_iadd,				/* nb_inplace_add */
-    wrap_isub,				/* nb_inplace_subtract */
-    wrap_imul,				/* nb_inplace_multiply */
-    wrap_idiv,				/* nb_inplace_divide */
-    wrap_imod,				/* nb_inplace_remainder */
-    (ternaryfunc)wrap_ipow,		/* nb_inplace_power */
-    wrap_ilshift,			/* nb_inplace_lshift */
-    wrap_irshift,			/* nb_inplace_rshift */
-    wrap_iand,				/* nb_inplace_and */
-    wrap_ixor,				/* nb_inplace_xor */
-    wrap_ior,				/* nb_inplace_or */
+    wrap_iadd,                              /* nb_inplace_add */
+    wrap_isub,                              /* nb_inplace_subtract */
+    wrap_imul,                              /* nb_inplace_multiply */
+#if PY_MAJOR_VERSION < 3
+    wrap_idiv,                              /* nb_inplace_divide */
+#endif
+    wrap_imod,                              /* nb_inplace_remainder */
+    (ternaryfunc)wrap_ipow,                 /* nb_inplace_power */
+    wrap_ilshift,                           /* nb_inplace_lshift */
+    wrap_irshift,                           /* nb_inplace_rshift */
+    wrap_iand,                              /* nb_inplace_and */
+    wrap_ixor,                              /* nb_inplace_xor */
+    wrap_ior,                               /* nb_inplace_or */
 
     /* Added in release 2.2 */
     /* These require the Py_TPFLAGS_HAVE_CLASS flag */
-    wrap_floordiv,			/* nb_floor_divide */
-    wrap_truediv,			/* nb_true_divide */
-    wrap_ifloordiv,			/* nb_inplace_floor_divide */
-    wrap_itruediv,			/* nb_inplace_true_divide */
+    wrap_floordiv,                          /* nb_floor_divide */
+    wrap_truediv,                           /* nb_true_divide */
+    wrap_ifloordiv,                         /* nb_inplace_floor_divide */
+    wrap_itruediv,                          /* nb_inplace_true_divide */
+    wrap_index,                             /* nb_index */
 };
 
 static PySequenceMethods
 wrap_as_sequence = {
-    wrap_length,			/* sq_length */
-    0,					/* sq_concat */
-    0,					/* sq_repeat */
-    0,					/* sq_item */
-    wrap_slice,				/* sq_slice */
-    0,					/* sq_ass_item */
-    wrap_ass_slice,			/* sq_ass_slice */
-    wrap_contains,			/* sq_contains */
+    wrap_length,                            /* sq_length */
+    0,                                      /* sq_concat */
+    0,                                      /* sq_repeat */
+    0,                                      /* sq_item */
+    wrap_slice,                             /* sq_slice */
+    0,                                      /* sq_ass_item */
+    wrap_ass_slice,                         /* sq_ass_slice */
+    wrap_contains,                          /* sq_contains */
 };
 
 static PyMappingMethods
 wrap_as_mapping = {
-    wrap_length,			/* mp_length */
-    wrap_getitem,			/* mp_subscript */
-    wrap_setitem,			/* mp_ass_subscript */
+    wrap_length,                            /* mp_length */
+    wrap_getitem,                           /* mp_subscript */
+    wrap_setitem,                           /* mp_ass_subscript */
 };
 
 static PyMethodDef
@@ -770,49 +887,61 @@ wrap_methods[] = {
  * be associated with the wrapper itself.
  */
 
-statichere PyTypeObject
+
+static PyTypeObject
 ProxyType = {
-    PyObject_HEAD_INIT(NULL)  /* PyObject_HEAD_INIT(&PyType_Type) */  
-    0,
+    PyVarObject_HEAD_INIT(NULL, 0)
     "zope.proxy.ProxyBase",
     sizeof(ProxyObject),
     0,
-    wrap_dealloc,			/* tp_dealloc */
-    wrap_print,				/* tp_print */
-    0,					/* tp_getattr */
-    0,					/* tp_setattr */
-    wrap_compare,			/* tp_compare */
-    wrap_repr,				/* tp_repr */
-    &wrap_as_number,			/* tp_as_number */
-    &wrap_as_sequence,			/* tp_as_sequence */
-    &wrap_as_mapping,			/* tp_as_mapping */
-    wrap_hash,				/* tp_hash */
-    wrap_call,				/* tp_call */
-    wrap_str,				/* tp_str */
-    wrap_getattro,			/* tp_getattro */
-    wrap_setattro,			/* tp_setattro */
-    0,					/* tp_as_buffer */
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC
-        | Py_TPFLAGS_CHECKTYPES | Py_TPFLAGS_BASETYPE, /* tp_flags */
-    0,					/* tp_doc */
-    wrap_traverse,			/* tp_traverse */
-    wrap_clear,				/* tp_clear */
-    wrap_richcompare,			/* tp_richcompare */
-    0,					/* tp_weaklistoffset */
-    wrap_iter,				/* tp_iter */
-    wrap_iternext,			/* tp_iternext */
-    wrap_methods,			/* tp_methods */
-    0,					/* tp_members */
-    0,					/* tp_getset */
-    0,					/* tp_base */
-    0,					/* tp_dict */
-    0,					/* tp_descr_get */
-    0,					/* tp_descr_set */
-    0,					/* tp_dictoffset */
-    wrap_init,				/* tp_init */
-    0,                   		/* tp_alloc */
-    wrap_new,				/* tp_new */
-    0, /*_PyObject_GC_Del,*/		/* tp_free */
+    wrap_dealloc,                           /* tp_dealloc */
+    wrap_print,                             /* tp_print */
+    0,                                      /* tp_getattr */
+    0,                                      /* tp_setattr */
+#if PY_MAJOR_VERSION < 3
+    wrap_compare,                           /* tp_compare */
+#else
+    0,                                      /* tp_reserved */
+#endif
+    wrap_repr,                              /* tp_repr */
+    &wrap_as_number,                        /* tp_as_number */
+    &wrap_as_sequence,                      /* tp_as_sequence */
+    &wrap_as_mapping,                       /* tp_as_mapping */
+    wrap_hash,                              /* tp_hash */
+    wrap_call,                              /* tp_call */
+    wrap_str,                               /* tp_str */
+    wrap_getattro,                          /* tp_getattro */
+    wrap_setattro,                          /* tp_setattro */
+    0,                                      /* tp_as_buffer */
+#if PY_MAJOR_VERSION < 3
+    Py_TPFLAGS_DEFAULT |
+    Py_TPFLAGS_HAVE_GC |
+    Py_TPFLAGS_CHECKTYPES |
+    Py_TPFLAGS_BASETYPE,                    /* tp_flags */
+#else // Py_TPFLAGS_CHECKTYPES is always true in Python 3 and removed.
+    Py_TPFLAGS_DEFAULT |
+    Py_TPFLAGS_HAVE_GC |
+    Py_TPFLAGS_BASETYPE,                    /* tp_flags */
+#endif
+    0,                                      /* tp_doc */
+    wrap_traverse,                          /* tp_traverse */
+    wrap_clear,                             /* tp_clear */
+    wrap_richcompare,                       /* tp_richcompare */
+    0,                                      /* tp_weaklistoffset */
+    wrap_iter,                              /* tp_iter */
+    wrap_iternext,                          /* tp_iternext */
+    wrap_methods,                           /* tp_methods */
+    0,                                      /* tp_members */
+    0,                                      /* tp_getset */
+    0,                                      /* tp_base */
+    0,                                      /* tp_dict */
+    0,                                      /* tp_descr_get */
+    0,                                      /* tp_descr_set */
+    0,                                      /* tp_dictoffset */
+    wrap_init,                              /* tp_init */
+    0,                                      /* tp_alloc */
+    wrap_new,                               /* tp_new */
+    0, /*PyObject_GC_Del,*/                 /* tp_free */
 };
 
 static PyObject *
@@ -853,14 +982,14 @@ api_getobject(PyObject *proxy)
 {
     if (proxy == NULL) {
         PyErr_SetString(PyExc_RuntimeError,
-			"cannot pass NULL to ProxyAPI.getobject()");
+                        "cannot pass NULL to ProxyAPI.getobject()");
         return NULL;
     }
     if (Proxy_Check(proxy))
         return Proxy_GET_OBJECT(proxy);
     else {
         PyErr_Format(PyExc_TypeError, "expected proxy object, got %s",
-		     proxy->ob_type->tp_name);
+                     proxy->ob_type->tp_name);
         return NULL;
     }
 }
@@ -886,9 +1015,9 @@ getobject__doc__[] =
 static PyObject *
 wrapper_getobject(PyObject *unused, PyObject *obj)
 {
-  if (Proxy_Check(obj)) 
+  if (Proxy_Check(obj))
     obj = Proxy_GET_OBJECT(obj);
-  
+
   if (obj == NULL)
     obj = Py_None;
 
@@ -896,6 +1025,28 @@ wrapper_getobject(PyObject *unused, PyObject *obj)
   return obj;
 }
 
+static char
+setobject__doc__[] =
+"setProxiedObject(proxy, object) --> object\n"
+"\n"
+"Set the underlying object for proxy, returning the old proxied object.\n"
+"Raises TypeError if proxy is not a proxy.\n";
+
+static PyObject *
+wrapper_setobject(PyObject *unused, PyObject *args)
+{
+  PyObject *proxy;
+  PyObject *object;
+  PyObject *result = NULL;
+  if (PyArg_ParseTuple(args, "O!O:setProxiedObject",
+                       &ProxyType, &proxy, &object)) {
+    result = Proxy_GET_OBJECT(proxy);
+    Py_INCREF(object);
+    ((ProxyObject *) proxy)->proxy_object = object;
+  }
+  return result;
+}
+
 static char
 isProxy__doc__[] =
 "Check whether the given object is a proxy\n"
@@ -910,7 +1061,7 @@ wrapper_isProxy(PyObject *unused, PyObject *args)
   PyObject *obj, *result;
   PyTypeObject *proxytype=&ProxyType;
 
-  if (! PyArg_ParseTuple(args, "O|O!:isProxy", 
+  if (! PyArg_ParseTuple(args, "O|O!:isProxy",
                          &obj, &PyType_Type, &proxytype)
       )
     return NULL;
@@ -920,7 +1071,7 @@ wrapper_isProxy(PyObject *unused, PyObject *args)
     if (PyObject_TypeCheck(obj, proxytype))
       {
         result = Py_True;
-	Py_INCREF(result);
+        Py_INCREF(result);
         return result;
       }
     obj = Proxy_GET_OBJECT(obj);
@@ -944,9 +1095,9 @@ removeAllProxies__doc__[] =
 static PyObject *
 wrapper_removeAllProxies(PyObject *unused, PyObject *obj)
 {
-  while (obj && Proxy_Check(obj)) 
+  while (obj && Proxy_Check(obj))
     obj = Proxy_GET_OBJECT(obj);
-  
+
   if (obj == NULL)
     obj = Py_None;
 
@@ -955,7 +1106,7 @@ wrapper_removeAllProxies(PyObject *unused, PyObject *obj)
 }
 
 static char
-sameProxiedObjects__doc__[] = 
+sameProxiedObjects__doc__[] =
 "Check whether two objects are the same or proxies of the same object";
 
 static PyObject *
@@ -966,10 +1117,10 @@ wrapper_sameProxiedObjects(PyObject *unused, PyObject *args)
   if (! PyArg_ParseTuple(args, "OO:sameProxiedObjects", &ob1, &ob2))
     return NULL;
 
-  while (ob1 && Proxy_Check(ob1)) 
+  while (ob1 && Proxy_Check(ob1))
     ob1 = Proxy_GET_OBJECT(ob1);
 
-  while (ob2 && Proxy_Check(ob2)) 
+  while (ob2 && Proxy_Check(ob2))
     ob2 = Proxy_GET_OBJECT(ob2);
 
   if (ob1 == ob2)
@@ -995,7 +1146,7 @@ wrapper_queryProxy(PyObject *unused, PyObject *args)
   PyObject *obj, *result=Py_None;
   PyTypeObject *proxytype=&ProxyType;
 
-  if (! PyArg_ParseTuple(args, "O|O!O:queryProxy", 
+  if (! PyArg_ParseTuple(args, "O|O!O:queryProxy",
                          &obj, &PyType_Type, &proxytype, &result)
       )
     return NULL;
@@ -1029,7 +1180,7 @@ wrapper_queryInnerProxy(PyObject *unused, PyObject *args)
   PyObject *obj, *result=Py_None;
   PyTypeObject *proxytype=&ProxyType;
 
-  if (! PyArg_ParseTuple(args, "O|O!O:queryInnerProxy", 
+  if (! PyArg_ParseTuple(args, "O|O!O:queryInnerProxy",
                          &obj, &PyType_Type, &proxytype, &result)
       )
     return NULL;
@@ -1045,6 +1196,8 @@ wrapper_queryInnerProxy(PyObject *unused, PyObject *args)
   return result;
 }
 
+/* Module initialization */
+
 static char
 module___doc__[] =
 "Association between an object, a context object, and a dictionary.\n\
@@ -1057,42 +1210,47 @@ act as proxies for the original object.";
 static PyMethodDef
 module_functions[] = {
     {"getProxiedObject", wrapper_getobject, METH_O, getobject__doc__},
+    {"setProxiedObject", wrapper_setobject, METH_VARARGS, setobject__doc__},
     {"isProxy", wrapper_isProxy, METH_VARARGS, isProxy__doc__},
-    {"sameProxiedObjects", wrapper_sameProxiedObjects, METH_VARARGS, 
+    {"sameProxiedObjects", wrapper_sameProxiedObjects, METH_VARARGS,
      sameProxiedObjects__doc__},
     {"queryProxy", wrapper_queryProxy, METH_VARARGS, queryProxy__doc__},
-    {"queryInnerProxy", wrapper_queryInnerProxy, METH_VARARGS, 
+    {"queryInnerProxy", wrapper_queryInnerProxy, METH_VARARGS,
      queryInnerProxy__doc__},
-    {"removeAllProxies", wrapper_removeAllProxies, METH_O, 
+    {"removeAllProxies", wrapper_removeAllProxies, METH_O,
      removeAllProxies__doc__},
     {NULL}
 };
 
-void
-init_zope_proxy_proxy(void)
+MOD_INIT(_zope_proxy_proxy)
 {
-    PyObject *m = Py_InitModule3("_zope_proxy_proxy", 
-                                 module_functions, module___doc__);
+    PyObject *m;
+
+    MOD_DEF(m, "_zope_proxy_proxy", module___doc__, module_functions)
 
     if (m == NULL)
-        return;
+        return MOD_ERROR_VAL;
 
     if (empty_tuple == NULL)
         empty_tuple = PyTuple_New(0);
 
-    ProxyType.tp_free = _PyObject_GC_Del;
+    ProxyType.tp_free = PyObject_GC_Del;
 
     if (PyType_Ready(&ProxyType) < 0)
-        return;
+        return MOD_ERROR_VAL;
 
     Py_INCREF(&ProxyType);
     PyModule_AddObject(m, "ProxyBase", (PyObject *)&ProxyType);
 
     if (api_object == NULL) {
-        api_object = PyCObject_FromVoidPtr(&wrapper_capi, NULL);
+        api_object = PyCapsule_New(&wrapper_capi, NULL, NULL);
         if (api_object == NULL)
-            return;
+        return MOD_ERROR_VAL;
     }
     Py_INCREF(api_object);
     PyModule_AddObject(m, "_CAPI", api_object);
+
+    return MOD_SUCCESS_VAL(m);
+
 }
+