All modules compiling under Py3k.

BTrees/BTreeModuleTemplate.c

@@ -15,6 +15,7 @@
 #include "Python.h"
 /* include structmember.h for offsetof */
 #include "structmember.h"
+#include "bytesobject.h"
 
 #ifdef PERSISTENT
 #include "persistent/cPersistence.h"
@@ -27,7 +28,7 @@
 #define PER_ACCESSED(O) 1
 #endif
 
-#include "py24compat.h"
+#include "_compat.h"
 
 /* So sue me.  This pair gets used all over the place, so much so that it
  * interferes with understanding non-persistence parts of algorithms.
@@ -65,7 +66,7 @@ static void PyVar_Assign(PyObject **v, PyObject *e) { Py_XDECREF(*v); *v=e;}
 #define MAX_BTREE_SIZE(B) DEFAULT_MAX_BTREE_SIZE
 #define MAX_BUCKET_SIZE(B) DEFAULT_MAX_BUCKET_SIZE
 
-#define SameType_Check(O1, O2) ((O1)->ob_type==(O2)->ob_type)
+#define SameType_Check(O1, O2) (Py_TYPE((O1))==Py_TYPE((O2)))
 
 #define ASSERT(C, S, R) if (! (C)) { \
   PyErr_SetString(PyExc_AssertionError, (S)); return (R); }
@@ -81,7 +82,7 @@ static void PyVar_Assign(PyObject **v, PyObject *e) { Py_XDECREF(*v); *v=e;}
 static int
 longlong_check(PyObject *ob)
 {
-    if (PyInt_Check(ob))
+    if (INT_CHECK(ob))
         return 1;
 
     if (PyLong_Check(ob)) {
@@ -101,10 +102,10 @@ longlong_as_object(PY_LONG_LONG val)
     static PY_LONG_LONG maxint = 0;
 
     if (maxint == 0)
-        maxint = PyInt_GetMax();
+        maxint = INT_GETMAX();
     if ((val > maxint) || (val < (-maxint-1)))
         return PyLong_FromLongLong(val);
-    return PyInt_FromLong((long)val);
+    return INT_FROM_LONG((long)val);
 }
 #endif
 
@@ -291,7 +292,7 @@ IndexError(int i)
 {
     PyObject *v;
 
-    v = PyInt_FromLong(i);
+    v = INT_FROM_LONG(i);
     if (!v) {
 	v = Py_None;
 	Py_INCREF(v);
@@ -451,7 +452,11 @@ BTREEITEMSTEMPLATE_C
 int
 init_persist_type(PyTypeObject *type)
 {
+#ifdef PY3K
+    ((PyObject*)type)->ob_type = &PyType_Type;
+#else
     type->ob_type = &PyType_Type;
+#endif
     type->tp_base = cPersistenceCAPI->pertype;
 
     if (PyType_Ready(type) < 0)
@@ -460,6 +465,21 @@ init_persist_type(PyTypeObject *type)
     return 1;
 }
 
+#ifdef PY3K
+static struct PyModuleDef moduledef = {
+        PyModuleDef_HEAD_INIT,
+        "_" MOD_NAME_PREFIX "BTree",    /* m_name */
+        BTree_module_documentation,     /* m_doc */
+        -1,                             /* m_size */
+        module_methods,                 /* m_methods */
+        NULL,                           /* m_reload */
+        NULL,                           /* m_traverse */
+        NULL,                           /* m_clear */
+        NULL,                           /* m_free */
+    };
+
+#endif
+
 void
 INITMODULE (void)
 {
@@ -471,87 +491,106 @@ INITMODULE (void)
       return;
 #endif
 
-    sort_str = PyString_InternFromString("sort");
+    sort_str = INTERN("sort");
     if (!sort_str)
-	return;
-    reverse_str = PyString_InternFromString("reverse");
+        return;
+    reverse_str = INTERN("reverse");
     if (!reverse_str)
-	return;
-    __setstate___str = PyString_InternFromString("__setstate__");
+        return;
+    __setstate___str = INTERN("__setstate__");
     if (!__setstate___str)
-	return;
-    _bucket_type_str = PyString_InternFromString("_bucket_type");
+        return;
+    _bucket_type_str = INTERN("_bucket_type");
     if (!_bucket_type_str)
-	return;
+        return;
 
     /* Grab the ConflictError class */
     m = PyImport_ImportModule("BTrees.Interfaces");
-    if (m != NULL) {
-  	c = PyObject_GetAttrString(m, "BTreesConflictError");
-  	if (c != NULL)
-	    ConflictError = c;
-	Py_DECREF(m);
+    if (m != NULL)
+    {
+        c = PyObject_GetAttrString(m, "BTreesConflictError");
+        if (c != NULL)
+            ConflictError = c;
+        Py_DECREF(m);
     }
 
-    if (ConflictError == NULL) {
-  	Py_INCREF(PyExc_ValueError);
-	ConflictError=PyExc_ValueError;
+    if (ConflictError == NULL)
+    {
+        Py_INCREF(PyExc_ValueError);
+        ConflictError=PyExc_ValueError;
     }
 
     /* Initialize the PyPersist_C_API and the type objects. */
-    cPersistenceCAPI = PyCObject_Import("persistent.cPersistence", "CAPI");
+#ifdef PY3K
+    cPersistenceCAPI = (cPersistenceCAPIstruct *)PyCapsule_Import(
+                "persistent.cPersistence.CAPI", 0);
+#else
+    cPersistenceCAPI = (cPersistenceCAPIstruct *)PyCObject_Import(
+                "persistent.cPersistence", "CAPI");
+#endif
     if (cPersistenceCAPI == NULL)
-	return;
+        return;
 
-    BTreeItemsType.ob_type = &PyType_Type;
-    BTreeIter_Type.ob_type = &PyType_Type;
+#ifdef PY3K
+#define _SET_TYPE(typ) ((PyObject*)(&typ))->ob_type = &PyType_Type
+#else
+#define _SET_TYPE(typ) (typ).ob_type = &PyType_Type
+#endif
+    _SET_TYPE(BTreeItemsType);
+    _SET_TYPE(BTreeIter_Type);
     BTreeIter_Type.tp_getattro = PyObject_GenericGetAttr;
     BucketType.tp_new = PyType_GenericNew;
     SetType.tp_new = PyType_GenericNew;
     BTreeType.tp_new = PyType_GenericNew;
     TreeSetType.tp_new = PyType_GenericNew;
     if (!init_persist_type(&BucketType))
-	return;
+	    return;
     if (!init_persist_type(&BTreeType))
-	return;
+	    return;
     if (!init_persist_type(&SetType))
-	return;
+	    return;
     if (!init_persist_type(&TreeSetType))
-	return;
+	    return;
 
     if (PyDict_SetItem(BTreeType.tp_dict, _bucket_type_str,
-		       (PyObject *)&BucketType) < 0) {
-	fprintf(stderr, "btree failed\n");
-	return;
+		       (PyObject *)&BucketType) < 0)
+    {
+        fprintf(stderr, "btree failed\n");
+        return;
     }
     if (PyDict_SetItem(TreeSetType.tp_dict, _bucket_type_str,
-		       (PyObject *)&SetType) < 0) {
-	fprintf(stderr, "bucket failed\n");
-	return;
+		       (PyObject *)&SetType) < 0)
+    {
+        fprintf(stderr, "bucket failed\n");
+        return;
     }
 
+#ifdef PY3K
+  m = PyModule_Create(&moduledef);
+#else
     /* Create the module and add the functions */
     m = Py_InitModule4("_" MOD_NAME_PREFIX "BTree",
 		       module_methods, BTree_module_documentation,
 		       (PyObject *)NULL, PYTHON_API_VERSION);
+#endif
 
     /* Add some symbolic constants to the module */
     d = PyModule_GetDict(m);
     if (PyDict_SetItemString(d, MOD_NAME_PREFIX "Bucket",
 			     (PyObject *)&BucketType) < 0)
-	return;
+        return;
     if (PyDict_SetItemString(d, MOD_NAME_PREFIX "BTree",
 			     (PyObject *)&BTreeType) < 0)
-	return;
+        return;
     if (PyDict_SetItemString(d, MOD_NAME_PREFIX "Set",
 			     (PyObject *)&SetType) < 0)
-	return;
+        return;
     if (PyDict_SetItemString(d, MOD_NAME_PREFIX "TreeSet",
 			     (PyObject *)&TreeSetType) < 0)
-	return;
+        return;
     if (PyDict_SetItemString(d, MOD_NAME_PREFIX "TreeIterator",
 			     (PyObject *)&BTreeIter_Type) < 0)
-	return;
+        return;
 	/* We also want to be able to access these constants without the prefix
 	 * so that code can more easily exchange modules (particularly the integer
 	 * and long modules, but also others).  The TreeIterator is only internal,
@@ -559,16 +598,16 @@ INITMODULE (void)
      */
     if (PyDict_SetItemString(d, "Bucket",
 			     (PyObject *)&BucketType) < 0)
-	return;
+        return;
     if (PyDict_SetItemString(d, "BTree",
 			     (PyObject *)&BTreeType) < 0)
-	return;
+        return;
     if (PyDict_SetItemString(d, "Set",
 			     (PyObject *)&SetType) < 0)
-	return;
+        return;
     if (PyDict_SetItemString(d, "TreeSet",
 			     (PyObject *)&TreeSetType) < 0)
-	return;
+        return;
 #if defined(ZODB_64BIT_INTS) && defined(NEED_LONG_LONG_SUPPORT)
     if (PyDict_SetItemString(d, "using64bits", Py_True) < 0)
         return;

BTrees/_compat.h

+/* Straddle Python 2 / 3 */
+#ifndef BTREES__COMPAT_H
+#define BTREES__COMPAT_H
+
+#if PY_MAJOR_VERSION >= 3
+
+#ifdef INTERN
+#undef INTERN
+#endif
+
+#ifdef INT_FROM_LONG
+#undef INT_FROM_LONG
+#endif
+
+#ifdef INT_CHECK
+#undef INT_CHECK
+#endif
+
+#define PY3K
+
+#define INTERN PyUnicode_InternFromString
+#define INT_FROM_LONG(x) PyLong_FromLong(x)
+#define INT_CHECK(x) PyLong_Check(x)
+#define INT_AS_LONG(x) PyLong_AS_LONG(x)
+#define INT_GETMAX(x) 2<<31
+#define TEXT_FROM_STRING PyUnicode_FromString
+#define TEXT_FORMAT PyUnicode_Format
+
+#define COMPARE(lhs, rhs) \
+    PyObject_RichCompareBool((lhs), (rhs), Py_LT) > 0 ? -1 : \
+    (PyObject_RichCompareBool((lhs), (rhs), Py_EQ) > 0 ? 0 : 1)
+
+#else
+
+#define INTERN PyString_InternFromString
+#define INT_FROM_LONG(x) PyInt_FromLong(x)
+#define INT_CHECK(x) PyInt_Check(x)
+#define INT_AS_LONG(x) PyInt_AS_LONG(x)
+#define INT_GETMAX(x) PyInt_GetMax(x)
+#define TEXT_FROM_STRING PyString_FromString
+#define TEXT_FORMAT PyString_Format
+
+#define COMPARE(lhs, rhs) PyObject_Compare((lhs), (rhs))
+
+#endif
+
+#endif /* BTREES__COMPAT_H */

BTrees/_fsBTree.c

@@ -40,14 +40,14 @@ typedef unsigned char char6[6];
 #define KEYMACROS_H "$Id$\n"
 #define KEY_TYPE char2
 #undef KEY_TYPE_IS_PYOBJECT
-#define KEY_CHECK(K) (PyString_Check(K) && PyString_GET_SIZE(K)==2)
+#define KEY_CHECK(K) (PyBytes_Check(K) && PyBytes_GET_SIZE(K)==2)
 #define TEST_KEY_SET_OR(V, K, T) if ( ( (V) = ((*(K) < *(T) || (*(K) == *(T) && (K)[1] < (T)[1])) ? -1 : ((*(K) == *(T) && (K)[1] == (T)[1]) ? 0 : 1)) ), 0 )
 #define DECREF_KEY(KEY)
 #define INCREF_KEY(k)
 #define COPY_KEY(KEY, E) (*(KEY)=*(E), (KEY)[1]=(E)[1])
-#define COPY_KEY_TO_OBJECT(O, K) O=PyString_FromStringAndSize((const char*)K,2)
+#define COPY_KEY_TO_OBJECT(O, K) O=PyBytes_FromStringAndSize((const char*)K,2)
 #define COPY_KEY_FROM_ARG(TARGET, ARG, STATUS) \
-  if (KEY_CHECK(ARG)) memcpy(TARGET, PyString_AS_STRING(ARG), 2); else { \
+  if (KEY_CHECK(ARG)) memcpy(TARGET, PyBytes_AS_STRING(ARG), 2); else { \
       PyErr_SetString(PyExc_TypeError, "expected two-character string key"); \
       (STATUS)=0; }
 
@@ -59,10 +59,10 @@ typedef unsigned char char6[6];
 #define DECREF_VALUE(k)
 #define INCREF_VALUE(k)
 #define COPY_VALUE(V, E) (memcpy(V, E, 6))
-#define COPY_VALUE_TO_OBJECT(O, K) O=PyString_FromStringAndSize((const char*)K,6)
+#define COPY_VALUE_TO_OBJECT(O, K) O=PyBytes_FromStringAndSize((const char*)K,6)
 #define COPY_VALUE_FROM_ARG(TARGET, ARG, STATUS) \
-  if ((PyString_Check(ARG) && PyString_GET_SIZE(ARG)==6)) \
-      memcpy(TARGET, PyString_AS_STRING(ARG), 6); else { \
+  if ((PyBytes_Check(ARG) && PyBytes_GET_SIZE(ARG)==6)) \
+      memcpy(TARGET, PyBytes_AS_STRING(ARG), 6); else { \
       PyErr_SetString(PyExc_TypeError, "expected six-character string key"); \
       (STATUS)=0; }
 
@@ -93,11 +93,11 @@ bucket_toString(PyObject *oself)
 
   len = self->len;
 
-  items = PyString_FromStringAndSize(NULL, len*8);
+  items = PyBytes_FromStringAndSize(NULL, len*8);
   if (items == NULL)
     goto err;
-  memcpy(PyString_AS_STRING(items),       self->keys,   len*2);
-  memcpy(PyString_AS_STRING(items)+len*2, self->values, len*6);
+  memcpy(PyBytes_AS_STRING(items),       self->keys,   len*2);
+  memcpy(PyBytes_AS_STRING(items)+len*2, self->values, len*6);
   
   PER_UNUSE(self);
   return items;
@@ -116,7 +116,7 @@ bucket_fromString(PyObject *oself, PyObject *state)
   KEY_TYPE *keys;
   VALUE_TYPE *values;
 
-  len = PyString_Size(state);
+  len = PyBytes_Size(state);
   if (len < 0)
     return NULL;
   
@@ -144,8 +144,8 @@ bucket_fromString(PyObject *oself, PyObject *state)
     self->size = len;
   }
 
-  memcpy(self->keys,   PyString_AS_STRING(state),       len*2);
-  memcpy(self->values, PyString_AS_STRING(state)+len*2, len*6);
+  memcpy(self->keys,   PyBytes_AS_STRING(state),       len*2);
+  memcpy(self->values, PyBytes_AS_STRING(state)+len*2, len*6);
 
   self->len = len;
 

BTrees/floatvaluemacros.h

@@ -13,7 +13,7 @@
 #define COPY_VALUE_TO_OBJECT(O, K) O=PyFloat_FromDouble(K)
 #define COPY_VALUE_FROM_ARG(TARGET, ARG, STATUS) \
   if (PyFloat_Check(ARG)) TARGET = (float)PyFloat_AsDouble(ARG); \
-  else if (PyInt_Check(ARG)) TARGET = (float)PyInt_AsLong(ARG); \
+  else if (INT_CHECK(ARG)) TARGET = (float)INT_AS_LONG(ARG); \
   else { \
       PyErr_SetString(PyExc_TypeError, "expected float or int value"); \
       (STATUS)=0; (TARGET)=0; }

BTrees/intkeymacros.h

@@ -8,7 +8,7 @@
 #define KEY_CHECK longlong_check
 #define COPY_KEY_TO_OBJECT(O, K) O=longlong_as_object(K)
 #define COPY_KEY_FROM_ARG(TARGET, ARG, STATUS) \
-    if (PyInt_Check(ARG)) TARGET=PyInt_AS_LONG(ARG); else \
+    if (INT_CHECK(ARG)) TARGET=INT_AS_LONG(ARG); else \
         if (longlong_check(ARG)) TARGET=PyLong_AsLongLong(ARG); else \
             if (PyLong_Check(ARG)) { \
                 PyErr_SetString(PyExc_ValueError, "long integer out of range"); \
@@ -19,11 +19,11 @@
 #else
 /* C int as key */
 #define KEY_TYPE int
-#define KEY_CHECK PyInt_Check
-#define COPY_KEY_TO_OBJECT(O, K) O=PyInt_FromLong(K)
+#define KEY_CHECK INT_CHECK
+#define COPY_KEY_TO_OBJECT(O, K) O=INT_FROM_LONG(K)
 #define COPY_KEY_FROM_ARG(TARGET, ARG, STATUS)                    \
-  if (PyInt_Check(ARG)) {                                         \
-      long vcopy = PyInt_AS_LONG(ARG);                            \
+  if (INT_CHECK(ARG)) {                                         \
+      long vcopy = INT_AS_LONG(ARG);                            \
       if ((int)vcopy != vcopy) {                                  \
         PyErr_SetString(PyExc_TypeError, "integer out of range"); \
         (STATUS)=0; (TARGET)=0;                                   \

BTrees/intvaluemacros.h

@@ -7,7 +7,7 @@
 #define VALUE_PARSE "L"
 #define COPY_VALUE_TO_OBJECT(O, K) O=longlong_as_object(K)
 #define COPY_VALUE_FROM_ARG(TARGET, ARG, STATUS) \
-    if (PyInt_Check(ARG)) TARGET=PyInt_AS_LONG(ARG); else \
+    if (INT_CHECK(ARG)) TARGET=INT_AS_LONG(ARG); else \
         if (longlong_check(ARG)) TARGET=PyLong_AsLongLong(ARG); else \
             if (PyLong_Check(ARG)) { \
                 PyErr_SetString(PyExc_ValueError, "long integer out of range"); \
@@ -18,11 +18,11 @@
 #else
 #define VALUE_TYPE int
 #define VALUE_PARSE "i"
-#define COPY_VALUE_TO_OBJECT(O, K) O=PyInt_FromLong(K)
+#define COPY_VALUE_TO_OBJECT(O, K) O=INT_FROM_LONG(K)
 
 #define COPY_VALUE_FROM_ARG(TARGET, ARG, STATUS)                  \
-  if (PyInt_Check(ARG)) {                                         \
-      long vcopy = PyInt_AS_LONG(ARG);                            \
+  if (INT_CHECK(ARG)) {                                         \
+      long vcopy = INT_AS_LONG(ARG);                            \
       if ((int)vcopy != vcopy) {                                  \
         PyErr_SetString(PyExc_TypeError, "integer out of range"); \
         (STATUS)=0; (TARGET)=0;                                   \

BTrees/objectkeymacros.h

@@ -3,35 +3,34 @@
 #define KEY_TYPE_IS_PYOBJECT
 
 #include "Python.h"
+#include "_compat.h"
 
 static PyObject *object_;
 
 static int
 check_argument_cmp(PyObject *arg)
 {
-  /* printf("check cmp %p %p %p %p\n",  */
-  /*        arg->ob_type->tp_richcompare, */
-  /*        ((PyTypeObject *)object_)->ob_type->tp_richcompare, */
-  /*        arg->ob_type->tp_compare, */
-  /*        ((PyTypeObject *)object_)->ob_type->tp_compare); */
+    /* printf("check cmp %p %p %p %p\n",  */
+    /*        arg->ob_type->tp_richcompare, */
+    /*        ((PyTypeObject *)object_)->ob_type->tp_richcompare, */
+    /*        arg->ob_type->tp_compare, */
+    /*        ((PyTypeObject *)object_)->ob_type->tp_compare); */
 
-  if (arg->ob_type->tp_richcompare == NULL
-      &&
-#if PY_MAJOR_VERSION==2 && PY_MINOR_VERSION < 6
-       arg->ob_type->tp_compare == NULL
-#else
-       arg->ob_type->tp_compare ==
-       ((PyTypeObject *)object_)->ob_type->tp_compare
+    if (Py_TYPE(arg)->tp_richcompare == NULL
+#ifndef PY3K
+        && Py_TYPE(arg)->tp_compare ==
+                ((PyTypeObject *)object_)->ob_type->tp_compare
 #endif
-      )
+    )
     {
-      PyErr_SetString(PyExc_TypeError, "Object has default comparison");
-      return 0;
+        PyErr_SetString(PyExc_TypeError, "Object has default comparison");
+        return 0;
     }
-  return 1;
+    return 1;
 }
 
-#define TEST_KEY_SET_OR(V, KEY, TARGET) if ( ( (V) = PyObject_Compare((KEY),(TARGET)) ), PyErr_Occurred() )
+#define TEST_KEY_SET_OR(V, KEY, TARGET) \
+if ( ( (V) = COMPARE((KEY),(TARGET)) ), PyErr_Occurred() )
 #define INCREF_KEY(k) Py_INCREF(k)
 #define DECREF_KEY(KEY) Py_DECREF(KEY)
 #define COPY_KEY(KEY, E) KEY=(E)

BTrees/objectvaluemacros.h

-
 #define VALUEMACROS_H "$Id$\n"
 
 #define VALUE_TYPE PyObject *
 #define VALUE_TYPE_IS_PYOBJECT
-#define TEST_VALUE(VALUE, TARGET) PyObject_Compare((VALUE),(TARGET))
+#define TEST_VALUE(VALUE, TARGET) COMPARE((VALUE),(TARGET))
 #define DECLARE_VALUE(NAME) VALUE_TYPE NAME
 #define INCREF_VALUE(k) Py_INCREF(k)
 #define DECREF_VALUE(k) Py_DECREF(k)

BTrees/py24compat.h

-/* Backport type definitions from Python 2.5's object.h */
-#ifndef BTREE_PY24COMPATH_H
-#define BTREE_PY24COMPAT_H
-#if PY_VERSION_HEX < 0x02050000
-typedef Py_ssize_t (*lenfunc)(PyObject *);
-typedef PyObject *(*ssizeargfunc)(PyObject *, Py_ssize_t);
-typedef PyObject *(*ssizessizeargfunc)(PyObject *, Py_ssize_t, Py_ssize_t);
-typedef int(*ssizeobjargproc)(PyObject *, Py_ssize_t, PyObject *);
-typedef int(*ssizessizeobjargproc)(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *);
-#endif /* PY_VERSION_HEX */
-#endif /* BTREE_PY24COMPAT_H */