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.
  */
@@ -173,12 +214,16 @@ WrapperType_Lookup(PyTypeObject *type, PyObject *name)
         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) {
+
+    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);
-        } else {
-            PyErr_Format(PyExc_TypeError,
-                "Tried to set attribute '%s' on wrapper, but it is not"
-                " a data descriptor", PyString_AS_STRING(name));
-        }
         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)
@@ -344,10 +413,6 @@ wrap_call(PyObject *self, PyObject *args, PyObject *kw)
         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)
 {
@@ -500,7 +580,9 @@ check2i(ProxyObject *self, PyObject *other,
 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
@@ -692,7 +796,9 @@ wrap_as_number = {
     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 */
@@ -706,19 +812,29 @@ wrap_as_number = {
     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 */
+#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 */
@@ -733,6 +849,7 @@ wrap_as_number = {
     wrap_truediv,                           /* nb_true_divide */
     wrap_ifloordiv,                         /* nb_inplace_floor_divide */
     wrap_itruediv,                          /* nb_inplace_true_divide */
+    wrap_index,                             /* nb_index */
 };
 
 static PySequenceMethods
@@ -770,10 +887,10 @@ 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,
@@ -781,7 +898,11 @@ ProxyType = {
     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 */
@@ -792,8 +913,16 @@ ProxyType = {
     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 */
+#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 */
@@ -812,7 +941,7 @@ ProxyType = {
     wrap_init,                              /* tp_init */
     0,                                      /* tp_alloc */
     wrap_new,                               /* tp_new */
-    0, /*_PyObject_GC_Del,*/		/* tp_free */
+    0, /*PyObject_GC_Del,*/                 /* tp_free */
 };
 
 static PyObject *
@@ -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"
@@ -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,6 +1210,7 @@ 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__doc__},
@@ -1068,31 +1222,35 @@ module_functions[] = {
     {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);
+
 }
+