Merge py3k branch.

.bzrignore

@@ -6,3 +6,4 @@ nosetests.xml
 coverage.xml
 *.egg
 docs/_build
+__pycache__

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,52 @@ 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
+
+
+#ifdef NEED_LONG_LONG_KEYS
+static int
+longlong_convert(PyObject *ob, PY_LONG_LONG *value)
+{
+#ifndef PY3K
+    if (PyInt_Check(ob))
+    {
+        (*value) = (PY_LONG_LONG)PyInt_AS_LONG(ob);
+        return 1;
+    }
+#endif
+
+    if (!PyLong_Check(ob))
+    {
+        PyErr_SetString(PyExc_TypeError, "expected integer key");
+        return 0;
+    }
+    else
+    {
+        PY_LONG_LONG val;
+#if PY_VERSION_HEX < 0x02070000
+        /* check magnitude */
+        val = PyLong_AsLongLong(ob);
+
+        if (val == -1 && PyErr_Occurred())
+            goto overflow;
+#else
+        int overflow;
+        val = PyLong_AsLongLongAndOverflow(ob, &overflow);
+        if (overflow)
+            goto overflow;
+#endif
+        (*value) = val;
+        return 1;
+    }
+overflow:
+    PyErr_SetString(PyExc_ValueError, "long integer out of range");
+    return 0;
 }
 #endif
 
@@ -291,7 +334,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 +494,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,120 +507,167 @@ init_persist_type(PyTypeObject *type)
     return 1;
 }
 
-void
-INITMODULE (void)
+#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
+
+static PyObject*
+module_init(void)
 {
-    PyObject *m, *d, *c;
+    PyObject *module, *mod_dict, *interfaces, *conflicterr;
 
 #ifdef KEY_TYPE_IS_PYOBJECT
-    object_ = PyTuple_GetItem(Py_None->ob_type->tp_bases, 0);
+    object_ = PyTuple_GetItem(Py_TYPE(Py_None)->tp_bases, 0);
     if (object_ == NULL)
-      return;
+      return NULL;
 #endif
 
-    sort_str = PyString_InternFromString("sort");
+    sort_str = INTERN("sort");
     if (!sort_str)
-	return;
-    reverse_str = PyString_InternFromString("reverse");
+        return NULL;
+    reverse_str = INTERN("reverse");
     if (!reverse_str)
-	return;
-    __setstate___str = PyString_InternFromString("__setstate__");
+        return NULL;
+    __setstate___str = INTERN("__setstate__");
     if (!__setstate___str)
-	return;
-    _bucket_type_str = PyString_InternFromString("_bucket_type");
+        return NULL;
+    _bucket_type_str = INTERN("_bucket_type");
     if (!_bucket_type_str)
-	return;
+        return NULL;
 
     /* 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);
+    interfaces = PyImport_ImportModule("BTrees.Interfaces");
+    if (interfaces != NULL)
+    {
+        conflicterr = PyObject_GetAttrString(interfaces, "BTreesConflictError");
+        if (conflicterr != NULL)
+            ConflictError = conflicterr;
+        Py_DECREF(interfaces);
     }
 
-    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 NULL;
 
-    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 NULL;
     if (!init_persist_type(&BTreeType))
-	return;
+	    return NULL;
     if (!init_persist_type(&SetType))
-	return;
+	    return NULL;
     if (!init_persist_type(&TreeSetType))
-	return;
+	    return NULL;
 
     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 NULL;
     }
     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 NULL;
     }
 
     /* Create the module and add the functions */
-    m = Py_InitModule4("_" MOD_NAME_PREFIX "BTree",
+#ifdef PY3K
+    module = PyModule_Create(&moduledef);
+#else
+    module = 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",
+    mod_dict = PyModule_GetDict(module);
+    if (PyDict_SetItemString(mod_dict, MOD_NAME_PREFIX "Bucket",
 			     (PyObject *)&BucketType) < 0)
-	return;
-    if (PyDict_SetItemString(d, MOD_NAME_PREFIX "BTree",
+        return NULL;
+    if (PyDict_SetItemString(mod_dict, MOD_NAME_PREFIX "BTree",
 			     (PyObject *)&BTreeType) < 0)
-	return;
-    if (PyDict_SetItemString(d, MOD_NAME_PREFIX "Set",
+        return NULL;
+    if (PyDict_SetItemString(mod_dict, MOD_NAME_PREFIX "Set",
 			     (PyObject *)&SetType) < 0)
-	return;
-    if (PyDict_SetItemString(d, MOD_NAME_PREFIX "TreeSet",
+        return NULL;
+    if (PyDict_SetItemString(mod_dict, MOD_NAME_PREFIX "TreeSet",
 			     (PyObject *)&TreeSetType) < 0)
-	return;
-    if (PyDict_SetItemString(d, MOD_NAME_PREFIX "TreeIterator",
+        return NULL;
+    if (PyDict_SetItemString(mod_dict, MOD_NAME_PREFIX "TreeIterator",
 			     (PyObject *)&BTreeIter_Type) < 0)
-	return;
+        return NULL;
 	/* 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,
 	 * so we don't bother to expose that.
      */
-    if (PyDict_SetItemString(d, "Bucket",
+    if (PyDict_SetItemString(mod_dict, "Bucket",
 			     (PyObject *)&BucketType) < 0)
-	return;
-    if (PyDict_SetItemString(d, "BTree",
+        return NULL;
+    if (PyDict_SetItemString(mod_dict, "BTree",
 			     (PyObject *)&BTreeType) < 0)
-	return;
-    if (PyDict_SetItemString(d, "Set",
+        return NULL;
+    if (PyDict_SetItemString(mod_dict, "Set",
 			     (PyObject *)&SetType) < 0)
-	return;
-    if (PyDict_SetItemString(d, "TreeSet",
+        return NULL;
+    if (PyDict_SetItemString(mod_dict, "TreeSet",
 			     (PyObject *)&TreeSetType) < 0)
-	return;
+        return NULL;
 #if defined(ZODB_64BIT_INTS) && defined(NEED_LONG_LONG_SUPPORT)
-    if (PyDict_SetItemString(d, "using64bits", Py_True) < 0)
-        return;
+    if (PyDict_SetItemString(mod_dict, "using64bits", Py_True) < 0)
+        return NULL;
 #else
-    if (PyDict_SetItemString(d, "using64bits", Py_False) < 0)
-        return;
+    if (PyDict_SetItemString(mod_dict, "using64bits", Py_False) < 0)
+        return NULL;
 #endif
+    return module;
+}
+
+#ifdef PY3K
+PyMODINIT_FUNC INITMODULE(void)
+{
+    return module_init();
 }
+#else
+PyMODINIT_FUNC INITMODULE(void)
+{
+    module_init();
+}
+#endif

BTrees/IFBTree.py

@@ -99,17 +99,8 @@ weightedUnionPy = _set_operation(_weightedUnion, IFSetPy)
 weightedIntersectionPy = _set_operation(_weightedIntersection, IFSetPy)
 
 try:
-    from _IFBTree import IFBucket
-    from _IFBTree import IFSet
-    from _IFBTree import IFBTree
-    from _IFBTree import IFTreeSet
-    from _IFBTree import difference
-    from _IFBTree import union
-    from _IFBTree import intersection
-    from _IFBTree import multiunion
-    from _OIBTree import weightedUnion
-    from _OIBTree import weightedIntersection
-except ImportError: #pragma NO COVER
+    from ._IFBTree import IFBucket
+except ImportError: #pragma NO COVER w/ C extensions
     IFBucket = IFBucketPy
     IFSet = IFSetPy
     IFBTree = IFBTreePy
@@ -120,6 +111,16 @@ except ImportError: #pragma NO COVER
     multiunion = multiunionPy
     weightedUnion = weightedUnionPy
     weightedIntersection = weightedIntersectionPy
+else: #pragma NO COVER w/o C extensions
+    from ._IFBTree import IFSet
+    from ._IFBTree import IFBTree
+    from ._IFBTree import IFTreeSet
+    from ._IFBTree import difference
+    from ._IFBTree import union
+    from ._IFBTree import intersection
+    from ._IFBTree import multiunion
+    from ._IFBTree import weightedUnion
+    from ._IFBTree import weightedIntersection
 
 Bucket = IFBucket
 Set = IFSet

BTrees/IIBTree.py

@@ -100,17 +100,8 @@ weightedUnionPy = _set_operation(_weightedUnion, IISetPy)
 weightedIntersectionPy = _set_operation(_weightedIntersection, IISetPy)
 
 try:
-    from _IIBTree import IIBucket
-    from _IIBTree import IISet
-    from _IIBTree import IIBTree
-    from _IIBTree import IITreeSet
-    from _IIBTree import difference
-    from _IIBTree import union
-    from _IIBTree import intersection
-    from _IIBTree import multiunion
-    from _IIBTree import weightedUnion
-    from _IIBTree import weightedIntersection
-except ImportError: #pragma NO COVER
+    from ._IIBTree import IIBucket
+except ImportError: #pragma NO COVER w/ C extensions
     IIBucket = IIBucketPy
     IISet = IISetPy
     IIBTree = IIBTreePy
@@ -121,6 +112,16 @@ except ImportError: #pragma NO COVER
     multiunion = multiunionPy
     weightedUnion = weightedUnionPy
     weightedIntersection = weightedIntersectionPy
+else: #pragma NO COVER w/o C extensions
+    from ._IIBTree import IISet
+    from ._IIBTree import IIBTree
+    from ._IIBTree import IITreeSet
+    from ._IIBTree import difference
+    from ._IIBTree import union
+    from ._IIBTree import intersection
+    from ._IIBTree import multiunion
+    from ._IIBTree import weightedUnion
+    from ._IIBTree import weightedIntersection
 
 Bucket = IIBucket
 Set = IISet

BTrees/IOBTree.py

@@ -83,15 +83,8 @@ intersectionPy = _set_operation(_intersection, IOSetPy)
 multiunionPy = _set_operation(_multiunion, IOSetPy)
 
 try:
-    from _IOBTree import IOBucket
-    from _IOBTree import IOSet
-    from _IOBTree import IOBTree
-    from _IOBTree import IOTreeSet
-    from _IOBTree import difference
-    from _IOBTree import union
-    from _IOBTree import intersection
-    from _IOBTree import multiunion
-except ImportError: #pragma NO COVER
+    from ._IOBTree import IOBucket
+except ImportError: #pragma NO COVER w/ C extensions
     IOBucket = IOBucketPy
     IOSet = IOSetPy
     IOBTree = IOBTreePy
@@ -100,6 +93,14 @@ except ImportError: #pragma NO COVER
     union = unionPy
     intersection = intersectionPy
     multiunion = multiunionPy
+else: #pragma NO COVER w/o C extensions
+    from ._IOBTree import IOSet
+    from ._IOBTree import IOBTree
+    from ._IOBTree import IOTreeSet
+    from ._IOBTree import difference
+    from ._IOBTree import union
+    from ._IOBTree import intersection
+    from ._IOBTree import multiunion
 
 Bucket = IOBucket
 Set = IOSet

BTrees/LFBTree.py

@@ -100,17 +100,8 @@ weightedUnionPy = _set_operation(_weightedUnion, LFSetPy)
 weightedIntersectionPy = _set_operation(_weightedIntersection, LFSetPy)
 
 try:
-    from _LFBTree import LFBucket
-    from _LFBTree import LFSet
-    from _LFBTree import LFBTree
-    from _LFBTree import LFTreeSet
-    from _LFBTree import difference
-    from _LFBTree import union
-    from _LFBTree import intersection
-    from _LFBTree import multiunion
-    from _OIBTree import weightedUnion
-    from _OIBTree import weightedIntersection
-except ImportError: #pragma NO COVER
+    from ._LFBTree import LFBucket
+except ImportError: #pragma NO COVER w/ C extensions
     LFBucket = LFBucketPy
     LFSet = LFSetPy
     LFBTree = LFBTreePy
@@ -121,6 +112,16 @@ except ImportError: #pragma NO COVER
     multiunion = multiunionPy
     weightedUnion = weightedUnionPy
     weightedIntersection = weightedIntersectionPy
+else: #pragma NO COVER w/o C extensions
+    from ._LFBTree import LFSet
+    from ._LFBTree import LFBTree
+    from ._LFBTree import LFTreeSet
+    from ._LFBTree import difference
+    from ._LFBTree import union
+    from ._LFBTree import intersection
+    from ._LFBTree import multiunion
+    from ._LFBTree import weightedUnion
+    from ._LFBTree import weightedIntersection
 
 Bucket = LFBucket
 Set = LFSet

BTrees/LLBTree.py

@@ -100,17 +100,8 @@ weightedUnionPy = _set_operation(_weightedUnion, LLSetPy)
 weightedIntersectionPy = _set_operation(_weightedIntersection, LLSetPy)
 
 try:
-    from _LLBTree import LLBucket
-    from _LLBTree import LLSet
-    from _LLBTree import LLBTree
-    from _LLBTree import LLTreeSet
-    from _LLBTree import difference
-    from _LLBTree import union
-    from _LLBTree import intersection
-    from _LLBTree import multiunion
-    from _LLBTree import weightedUnion
-    from _LLBTree import weightedIntersection
-except ImportError: #pragma NO COVER
+    from ._LLBTree import LLBucket
+except ImportError: #pragma NO COVER w/ C extensions
     LLBucket = LLBucketPy
     LLSet = LLSetPy
     LLBTree = LLBTreePy
@@ -121,6 +112,16 @@ except ImportError: #pragma NO COVER
     multiunion = multiunionPy
     weightedUnion = weightedUnionPy
     weightedIntersection = weightedIntersectionPy
+else: #pragma NO COVER w/o C extensions
+    from ._LLBTree import LLSet
+    from ._LLBTree import LLBTree
+    from ._LLBTree import LLTreeSet
+    from ._LLBTree import difference
+    from ._LLBTree import union
+    from ._LLBTree import intersection
+    from ._LLBTree import multiunion
+    from ._LLBTree import weightedUnion
+    from ._LLBTree import weightedIntersection
 
 Bucket = LLBucket
 Set = LLSet

BTrees/LOBTree.py

@@ -83,15 +83,8 @@ intersectionPy = _set_operation(_intersection, LOSetPy)
 multiunionPy = _set_operation(_multiunion, LOSetPy)
 
 try:
-    from _LOBTree import LOBucket
-    from _LOBTree import LOSet
-    from _LOBTree import LOBTree
-    from _LOBTree import LOTreeSet
-    from _LOBTree import difference
-    from _LOBTree import union
-    from _LOBTree import intersection
-    from _LOBTree import multiunion
-except ImportError: #pragma NO COVER
+    from ._LOBTree import LOBucket
+except ImportError: #pragma NO COVER w/ C extensions
     LOBucket = LOBucketPy
     LOSet = LOSetPy
     LOBTree = LOBTreePy
@@ -100,6 +93,14 @@ except ImportError: #pragma NO COVER
     union = unionPy
     intersection = intersectionPy
     multiunion = multiunionPy
+else: #pragma NO COVER w/o C extensions
+    from ._LOBTree import LOSet
+    from ._LOBTree import LOBTree
+    from ._LOBTree import LOTreeSet
+    from ._LOBTree import difference
+    from ._LOBTree import union
+    from ._LOBTree import intersection
+    from ._LOBTree import multiunion
 
 Bucket = LOBucket
 Set = LOSet

BTrees/OIBTree.py

@@ -97,16 +97,8 @@ weightedUnionPy = _set_operation(_weightedUnion, OISetPy)
 weightedIntersectionPy = _set_operation(_weightedIntersection, OISetPy)
 
 try:
-    from _OIBTree import OIBucket
-    from _OIBTree import OISet
-    from _OIBTree import OIBTree
-    from _OIBTree import OITreeSet
-    from _OIBTree import difference
-    from _OIBTree import union
-    from _OIBTree import intersection
-    from _OIBTree import weightedUnion
-    from _OIBTree import weightedIntersection
-except ImportError: #pragma NO COVER
+    from ._OIBTree import OIBucket
+except ImportError: #pragma NO COVER w/ C extensions
     OIBucket = OIBucketPy
     OISet = OISetPy
     OIBTree = OIBTreePy
@@ -116,6 +108,15 @@ except ImportError: #pragma NO COVER
     intersection = intersectionPy
     weightedUnion = weightedUnionPy
     weightedIntersection = weightedIntersectionPy
+else: #pragma NO COVER w/o C extensions
+    from ._OIBTree import OISet
+    from ._OIBTree import OIBTree
+    from ._OIBTree import OITreeSet
+    from ._OIBTree import difference
+    from ._OIBTree import union
+    from ._OIBTree import intersection
+    from ._OIBTree import weightedUnion
+    from ._OIBTree import weightedIntersection
 
 
 Bucket = OIBucket

BTrees/OLBTree.py

@@ -98,16 +98,8 @@ weightedUnionPy = _set_operation(_weightedUnion, OLSetPy)
 weightedIntersectionPy = _set_operation(_weightedIntersection, OLSetPy)
 
 try:
-    from _OLBTree import OLBucket
-    from _OLBTree import OLSet
-    from _OLBTree import OLBTree
-    from _OLBTree import OLTreeSet
-    from _OLBTree import difference
-    from _OLBTree import union
-    from _OLBTree import intersection
-    from _OLBTree import weightedUnion
-    from _OLBTree import weightedIntersection
-except ImportError: #pragma NO COVER
+    from ._OLBTree import OLBucket
+except ImportError: #pragma NO COVER w/ C extensions
     OLBucket = OLBucketPy
     OLSet = OLSetPy
     OLBTree = OLBTreePy
@@ -117,6 +109,15 @@ except ImportError: #pragma NO COVER
     intersection = intersectionPy
     weightedUnion = weightedUnionPy
     weightedIntersection = weightedIntersectionPy
+else: #pragma NO COVER w/o C extensions
+    from ._OLBTree import OLSet
+    from ._OLBTree import OLBTree
+    from ._OLBTree import OLTreeSet
+    from ._OLBTree import difference
+    from ._OLBTree import union
+    from ._OLBTree import intersection
+    from ._OLBTree import weightedUnion
+    from ._OLBTree import weightedIntersection
 
 Bucket = OLBucket
 Set = OLSet

BTrees/OOBTree.py

@@ -78,14 +78,8 @@ unionPy = _set_operation(_union, OOSetPy)
 intersectionPy = _set_operation(_intersection, OOSetPy)
 
 try:
-    from _OOBTree import OOBucket
-    from _OOBTree import OOSet
-    from _OOBTree import OOBTree
-    from _OOBTree import OOTreeSet
-    from _OOBTree import difference
-    from _OOBTree import union
-    from _OOBTree import intersection
-except ImportError: #pragma NO COVER
+    from ._OOBTree import OOBucket
+except ImportError as e: #pragma NO COVER w/ C extensions
     OOBucket = OOBucketPy
     OOSet = OOSetPy
     OOBTree = OOBTreePy
@@ -93,6 +87,13 @@ except ImportError: #pragma NO COVER
     difference = differencePy
     union = unionPy
     intersection = intersectionPy
+else: #pragma NO COVER w/o C extensions
+    from ._OOBTree import OOSet
+    from ._OOBTree import OOBTree
+    from ._OOBTree import OOTreeSet
+    from ._OOBTree import difference
+    from ._OOBTree import union
+    from ._OOBTree import intersection
 
 Bucket = OOBucket
 Set = OOSet

BTrees/_IFBTree.c

@@ -25,10 +25,17 @@
 #define PERSISTENT
 
 #define MOD_NAME_PREFIX "IF"
-#define INITMODULE init_IFBTree
+
 #define DEFAULT_MAX_BUCKET_SIZE 120
 #define DEFAULT_MAX_BTREE_SIZE 500
 
+#include "_compat.h"
 #include "intkeymacros.h"
 #include "floatvaluemacros.h"
+
+#ifdef PY3K
+#define INITMODULE PyInit__IFBTree
+#else
+#define INITMODULE init_IFBTree
+#endif
 #include "BTreeModuleTemplate.c"

BTrees/_IIBTree.c

@@ -25,10 +25,17 @@
 #define PERSISTENT
 
 #define MOD_NAME_PREFIX "II"
-#define INITMODULE init_IIBTree
+
 #define DEFAULT_MAX_BUCKET_SIZE 120
 #define DEFAULT_MAX_BTREE_SIZE 500
 
+#include "_compat.h"
 #include "intkeymacros.h"
 #include "intvaluemacros.h"
+
+#ifdef PY3K
+#define INITMODULE PyInit__IIBTree
+#else
+#define INITMODULE init_IIBTree
+#endif
 #include "BTreeModuleTemplate.c"

BTrees/_IOBTree.c

@@ -23,10 +23,17 @@
 #define PERSISTENT
 
 #define MOD_NAME_PREFIX "IO"
+
 #define DEFAULT_MAX_BUCKET_SIZE 60
 #define DEFAULT_MAX_BTREE_SIZE 500
-#define INITMODULE init_IOBTree
                                 
+#include "_compat.h"
 #include "intkeymacros.h"
 #include "objectvaluemacros.h"
+
+#ifdef PY3K
+#define INITMODULE PyInit__IOBTree
+#else
+#define INITMODULE init_IOBTree
+#endif
 #include "BTreeModuleTemplate.c"

BTrees/_LFBTree.c

@@ -25,12 +25,19 @@
 #define PERSISTENT
 
 #define MOD_NAME_PREFIX "LF"
-#define INITMODULE init_LFBTree
+
 #define DEFAULT_MAX_BUCKET_SIZE 120
 #define DEFAULT_MAX_BTREE_SIZE 500
 
 #define ZODB_64BIT_INTS
 
+#include "_compat.h"
 #include "intkeymacros.h"
 #include "floatvaluemacros.h"
+
+#ifdef PY3K
+#define INITMODULE PyInit__LFBTree
+#else
+#define INITMODULE init_LFBTree
+#endif
 #include "BTreeModuleTemplate.c"

BTrees/_LLBTree.c

@@ -25,12 +25,19 @@
 #define PERSISTENT
 
 #define MOD_NAME_PREFIX "LL"
-#define INITMODULE init_LLBTree
+
 #define DEFAULT_MAX_BUCKET_SIZE 120
 #define DEFAULT_MAX_BTREE_SIZE 500
 
 #define ZODB_64BIT_INTS
 
+#include "_compat.h"
 #include "intkeymacros.h"
 #include "intvaluemacros.h"
+
+#ifdef PY3K
+#define INITMODULE PyInit__LLBTree
+#else
+#define INITMODULE init_LLBTree
+#endif
 #include "BTreeModuleTemplate.c"

BTrees/_LOBTree.c

@@ -23,12 +23,19 @@
 #define PERSISTENT
 
 #define MOD_NAME_PREFIX "LO"
+
 #define DEFAULT_MAX_BUCKET_SIZE 60
 #define DEFAULT_MAX_BTREE_SIZE 500
-#define INITMODULE init_LOBTree
 
 #define ZODB_64BIT_INTS
 
+#include "_compat.h"
 #include "intkeymacros.h"
 #include "objectvaluemacros.h"
+
+#ifdef PY3K
+#define INITMODULE PyInit__LOBTree
+#else
+#define INITMODULE init_LOBTree
+#endif
 #include "BTreeModuleTemplate.c"

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/tests/test_OIBTree.py

@@ -143,6 +143,7 @@ class _TestOIBTreesBase(TypeTest):
         self._makeOne()[1] = None
 
     def testEmptyFirstBucketReportedByGuido(self):
+        from .._compat import xrange
         b = self._makeOne()
         for i in xrange(29972): # reduce to 29971 and it works
             b[i] = i