[Zodb-checkins] CVS: Zope/lib/python/BTrees -
BTreeItemsTemplate.c:1.19.42.1
BTreeModuleTemplate.c:1.37.122.1 BTreeTemplate.c:1.74.36.1
BucketTemplate.c:1.54.32.1 IIBTree.py:1.7.44.1
IOBTree.py:1.7.44.1 Interfaces.py:1.18.122.1
Length.py:1.6.118.1 MergeTemplate.c:1.16.44.1
OIBTree.py:1.8.44.1 OOBTree.py:1.8.44.1
SetOpTemplate.c:1.29.122.1 SetTemplate.c:1.16.78.1
TreeSetTemplate.c:1.15.78.1 _IIBTree.c:1.7.122.1
_IOBTree.c:1.5.180.1 _OIBTree.c:1.2.298.1
_OOBTree.c:1.2.298.1 __init__.py:1.5.180.1
_fsBTree.c:1.7.12.1 sorters.c:1.4.124.1
Jim Fulton
cvs-admin at zope.org
Tue Nov 25 15:17:58 EST 2003
Update of /cvs-repository/Zope/lib/python/BTrees
In directory cvs.zope.org:/tmp/cvs-serv24052/lib/python/BTrees
Modified Files:
Tag: Zope-2_8-devel-branch
BTreeItemsTemplate.c BTreeModuleTemplate.c BTreeTemplate.c
BucketTemplate.c IIBTree.py IOBTree.py Interfaces.py Length.py
MergeTemplate.c OIBTree.py OOBTree.py SetOpTemplate.c
SetTemplate.c TreeSetTemplate.c _IIBTree.c _IOBTree.c
_OIBTree.c _OOBTree.c __init__.py _fsBTree.c sorters.c
Log Message:
merged everything but ZODB and ZEO from zodb33-devel-branch
=== Zope/lib/python/BTrees/BTreeItemsTemplate.c 1.19 => 1.19.42.1 ===
--- Zope/lib/python/BTrees/BTreeItemsTemplate.c:1.19 Sun Mar 16 16:42:29 2003
+++ Zope/lib/python/BTrees/BTreeItemsTemplate.c Tue Nov 25 15:17:25 2003
@@ -72,44 +72,43 @@
static int
BTreeItems_length_or_nonzero(BTreeItems *self, int nonzero)
{
- int r;
- Bucket *b, *next;
+ int r;
+ Bucket *b, *next;
- b=self->firstbucket;
- UNLESS(b) return 0;
-
- r=self->last + 1 - self->first;
-
- if (nonzero && r > 0)
- /* Short-circuit if all we care about is nonempty */
- return 1;
-
- if (b == self->lastbucket) return r;
-
- Py_INCREF(b);
- PER_USE_OR_RETURN(b, -1);
- while ((next=b->next))
- {
- r += b->len;
- if (nonzero && r > 0)
- /* Short-circuit if all we care about is nonempty */
- break;
-
- if (next == self->lastbucket)
- break; /* we already counted the last bucket */
-
- Py_INCREF(next);
- PER_ALLOW_DEACTIVATION(b);
- PER_ACCESSED(b);
- Py_DECREF(b);
- b=next;
- PER_USE_OR_RETURN(b, -1);
- }
- PER_ALLOW_DEACTIVATION(b);
- PER_ACCESSED(b);
- Py_DECREF(b);
+ b = self->firstbucket;
+ if (b == NULL)
+ return 0;
+
+ r = self->last + 1 - self->first;
+
+ if (nonzero && r > 0)
+ /* Short-circuit if all we care about is nonempty */
+ return 1;
+
+ if (b == self->lastbucket)
+ return r;
+
+ Py_INCREF(b);
+ PER_USE_OR_RETURN(b, -1);
+ while ((next = b->next)) {
+ r += b->len;
+ if (nonzero && r > 0)
+ /* Short-circuit if all we care about is nonempty */
+ break;
+
+ if (next == self->lastbucket)
+ break; /* we already counted the last bucket */
+
+ Py_INCREF(next);
+ PER_UNUSE(b);
+ Py_DECREF(b);
+ b = next;
+ PER_USE_OR_RETURN(b, -1);
+ }
+ PER_UNUSE(b);
+ Py_DECREF(b);
- return r >= 0 ? r : 0;
+ return r >= 0 ? r : 0;
}
static int
@@ -167,8 +166,7 @@
PER_USE_OR_RETURN(currentbucket, -1);
max = currentbucket->len - currentoffset - 1;
b = currentbucket->next;
- PER_ALLOW_DEACTIVATION(currentbucket);
- PER_ACCESSED(currentbucket);
+ PER_UNUSE(currentbucket);
if (delta <= max) {
currentoffset += delta;
pseudoindex += delta;
@@ -206,8 +204,7 @@
delta += currentoffset + 1;
PER_USE_OR_RETURN(currentbucket, -1);
currentoffset = currentbucket->len - 1;
- PER_ALLOW_DEACTIVATION(currentbucket);
- PER_ACCESSED(currentbucket);
+ PER_UNUSE(currentbucket);
}
assert(pseudoindex == i);
@@ -218,8 +215,7 @@
*/
PER_USE_OR_RETURN(currentbucket, -1);
error = currentoffset < 0 || currentoffset >= currentbucket->len;
- PER_ALLOW_DEACTIVATION(currentbucket);
- PER_ACCESSED(currentbucket);
+ PER_UNUSE(currentbucket);
if (error) {
PyErr_SetString(PyExc_RuntimeError,
"the bucket being iterated changed size");
@@ -238,6 +234,61 @@
return -1;
}
+
+/* Return the right kind ('k','v','i') of entry from bucket b at offset i.
+ * b must be activated. Returns NULL on error.
+ */
+static PyObject *
+getBucketEntry(Bucket *b, int i, char kind)
+{
+ PyObject *result = NULL;
+
+ assert(b);
+ assert(0 <= i && i < b->len);
+
+ switch (kind) {
+
+ case 'k':
+ COPY_KEY_TO_OBJECT(result, b->keys[i]);
+ break;
+
+ case 'v':
+ COPY_VALUE_TO_OBJECT(result, b->values[i]);
+ break;
+
+ case 'i': {
+ PyObject *key;
+ PyObject *value;;
+
+ COPY_KEY_TO_OBJECT(key, b->keys[i]);
+ if (!key) break;
+
+ COPY_VALUE_TO_OBJECT(value, b->values[i]);
+ if (!value) {
+ Py_DECREF(key);
+ break;
+ }
+
+ result = PyTuple_New(2);
+ if (result) {
+ PyTuple_SET_ITEM(result, 0, key);
+ PyTuple_SET_ITEM(result, 1, value);
+ }
+ else {
+ Py_DECREF(key);
+ Py_DECREF(value);
+ }
+ break;
+ }
+
+ default:
+ PyErr_SetString(PyExc_AssertionError,
+ "getBucketEntry: unknown kind");
+ break;
+ }
+ return result;
+}
+
/*
** BTreeItems_item
**
@@ -250,44 +301,15 @@
static PyObject *
BTreeItems_item(BTreeItems *self, int i)
{
- PyObject *r, *k=0, *v=0;
-
- if (BTreeItems_seek(self, i) < 0) return NULL;
-
- PER_USE_OR_RETURN(self->currentbucket, NULL);
-
- switch(self->kind) {
-
- case 'v':
- COPY_VALUE_TO_OBJECT(r, self->currentbucket->values[self->currentoffset]);
- break;
-
- case 'i':
- COPY_KEY_TO_OBJECT(k, self->currentbucket->keys[self->currentoffset]);
- UNLESS (k) return NULL;
-
- COPY_VALUE_TO_OBJECT(v, self->currentbucket->values[self->currentoffset]);
- UNLESS (v) return NULL;
+ PyObject *result;
- UNLESS (r=PyTuple_New(2)) goto err;
+ if (BTreeItems_seek(self, i) < 0) return NULL;
- PyTuple_SET_ITEM(r, 0, k);
- PyTuple_SET_ITEM(r, 1, v);
- break;
-
- default:
- COPY_KEY_TO_OBJECT(r, self->currentbucket->keys[self->currentoffset]);
- break;
- }
-
- PER_UNUSE(self->currentbucket);
- return r;
-
- err:
- Py_DECREF(k);
- Py_XDECREF(v);
- PER_UNUSE(self->currentbucket);
- return NULL;
+ PER_USE_OR_RETURN(self->currentbucket, NULL);
+ result = getBucketEntry(self->currentbucket, self->currentoffset,
+ self->kind);
+ PER_UNUSE(self->currentbucket);
+ return result;
}
/*
@@ -438,10 +460,10 @@
BTreeItems *self;
UNLESS (self = PyObject_NEW(BTreeItems, &BTreeItemsType)) return NULL;
- self->kind = kind;
+ self->kind=kind;
- self->first = lowoffset;
- self->last = highoffset;
+ self->first=lowoffset;
+ self->last=highoffset;
if (! lowbucket || ! highbucket
|| (lowbucket == highbucket && lowoffset > highoffset))
@@ -454,9 +476,9 @@
{
Py_INCREF(lowbucket);
self->firstbucket = lowbucket;
- Py_XINCREF(highbucket);
+ Py_INCREF(highbucket);
self->lastbucket = highbucket;
- Py_XINCREF(lowbucket);
+ Py_INCREF(lowbucket);
self->currentbucket = lowbucket;
}
@@ -550,3 +572,141 @@
}
return 0;
}
+
+/* Support for the iteration protocol new in Python 2.2. */
+
+static PyTypeObject BTreeIter_Type;
+
+/* The type of iterator objects, returned by e.g. iter(IIBTree()). */
+typedef struct {
+ PyObject_HEAD
+ /* We use a BTreeItems object because it's convenient and flexible.
+ * We abuse it two ways:
+ * 1. We set currentbucket to NULL when the iteration is finished.
+ * 2. We don't bother keeping pseudoindex in synch.
+ */
+ BTreeItems *pitems;
+} BTreeIter;
+
+/* Return a new iterator object, to traverse the keys and/or values
+ * represented by pitems. pitems must not be NULL. Returns NULL if error.
+ */
+static BTreeIter *
+BTreeIter_new(BTreeItems *pitems)
+{
+ BTreeIter *result;
+
+ assert(pitems != NULL);
+ result = PyObject_New(BTreeIter, &BTreeIter_Type);
+ if (result) {
+ Py_INCREF(pitems);
+ result->pitems = pitems;
+ }
+ return result;
+}
+
+/* The iterator's tp_dealloc slot. */
+static void
+BTreeIter_dealloc(BTreeIter *bi)
+{
+ Py_DECREF(bi->pitems);
+ PyObject_Del(bi);
+}
+
+/* The implementation of the iterator's tp_iternext slot. Returns "the next"
+ * item; returns NULL if error; returns NULL without setting an error if the
+ * iteration is exhausted (that's the way to terminate the iteration protocol).
+ */
+static PyObject *
+BTreeIter_next(BTreeIter *bi, PyObject *args)
+{
+ PyObject *result = NULL; /* until proven innocent */
+ BTreeItems *items = bi->pitems;
+ int i = items->currentoffset;
+ Bucket *bucket = items->currentbucket;
+
+ if (bucket == NULL) /* iteration termination is sticky */
+ return NULL;
+
+ PER_USE_OR_RETURN(bucket, NULL);
+ if (i >= bucket->len) {
+ /* We never leave this routine normally with i >= len: somebody
+ * else mutated the current bucket.
+ */
+ PyErr_SetString(PyExc_RuntimeError,
+ "the bucket being iterated changed size");
+ /* Arrange for that this error is sticky too. */
+ items->currentoffset = INT_MAX;
+ goto Done;
+ }
+
+ /* Build the result object, from bucket at offset i. */
+ result = getBucketEntry(bucket, i, items->kind);
+
+ /* Advance position for next call. */
+ if (bucket == items->lastbucket && i >= items->last) {
+ /* Next call should terminate the iteration. */
+ Py_DECREF(items->currentbucket);
+ items->currentbucket = NULL;
+ }
+ else {
+ ++i;
+ if (i >= bucket->len) {
+ Py_XINCREF(bucket->next);
+ items->currentbucket = bucket->next;
+ Py_DECREF(bucket);
+ i = 0;
+ }
+ items->currentoffset = i;
+ }
+
+Done:
+ PER_UNUSE(bucket);
+ return result;
+}
+
+static PyObject *
+BTreeIter_getiter(PyObject *it)
+{
+ Py_INCREF(it);
+ return it;
+}
+
+static PyTypeObject BTreeIter_Type = {
+ PyObject_HEAD_INIT(NULL)
+ 0, /* ob_size */
+ MOD_NAME_PREFIX "-iterator", /* tp_name */
+ sizeof(BTreeIter), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ /* methods */
+ (destructor)BTreeIter_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ 0, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /*PyObject_GenericGetAttr,*/ /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT, /* tp_flags */
+ 0, /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ (getiterfunc)BTreeIter_getiter, /* tp_iter */
+ (iternextfunc)BTreeIter_next, /* tp_iternext */
+ 0, /* tp_methods */
+ 0, /* tp_members */
+ 0, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+};
=== Zope/lib/python/BTrees/BTreeModuleTemplate.c 1.37 => 1.37.122.1 ===
--- Zope/lib/python/BTrees/BTreeModuleTemplate.c:1.37 Tue Jun 25 18:02:27 2002
+++ Zope/lib/python/BTrees/BTreeModuleTemplate.c Tue Nov 25 15:17:25 2003
@@ -12,34 +12,20 @@
****************************************************************************/
+#include "Python.h"
+/* include structmember.h for offsetof */
+#include "structmember.h"
+
#ifdef PERSISTENT
#include "cPersistence.h"
-
-/***************************************************************
- The following are macros that ought to be in cPersistence.h */
-#ifndef PER_USE
-
-#define PER_USE(O) \
-(((O)->state != cPersistent_GHOST_STATE \
- || (cPersistenceCAPI->setstate((PyObject*)(O)) >= 0)) \
- ? (((O)->state==cPersistent_UPTODATE_STATE) \
- ? ((O)->state=cPersistent_STICKY_STATE) : 1) : 0)
-
-#define PER_ACCESSED(O) ((O)->atime=((long)(time(NULL)/3))%65536)
-
-
-#endif
-/***************************************************************/
-
+//#include "persistence/persistenceAPI.h"
#else
-#include "ExtensionClass.h"
#define PER_USE_OR_RETURN(self, NULL)
#define PER_ALLOW_DEACTIVATION(self)
#define PER_PREVENT_DEACTIVATION(self)
#define PER_DEL(self)
#define PER_USE(O) 1
#define PER_ACCESSED(O) 1
-#define PER_CHANGED(O) 0
#endif
/* So sue me. This pair gets used all over the place, so much so that it
@@ -53,15 +39,23 @@
PER_ACCESSED(OBJ); \
} while (0)
-static PyObject *sort_str, *reverse_str, *items_str, *__setstate___str;
+/*
+ The tp_name slots of the various BTree types contain the fully
+ qualified names of the types, e.g. zodb.btrees.OOBTree.OOBTree.
+ The full name is usd to support pickling and because it is not
+ possible to modify the __module__ slot of a type dynamically. (This
+ may be a bug in Python 2.2).
+*/
+
+#define MODULE_NAME "BTrees._" MOD_NAME_PREFIX "BTree."
+
+static PyObject *sort_str, *reverse_str, *__setstate___str,
+ *_bucket_type_str;
static PyObject *ConflictError = NULL;
static void PyVar_Assign(PyObject **v, PyObject *e) { Py_XDECREF(*v); *v=e;}
#define ASSIGN(V,E) PyVar_Assign(&(V),(E))
-#define ASSIGNC(V,E) (Py_INCREF((E)), PyVar_Assign(&(V),(E)))
#define UNLESS(E) if (!(E))
-#define UNLESS_ASSIGN(V,E) ASSIGN(V,E); UNLESS(V)
-#define LIST(O) ((PyListObject*)(O))
#define OBJECT(O) ((PyObject*)(O))
#define MIN_BUCKET_ALLOC 16
@@ -150,7 +144,8 @@
BTreeItem *data;
} BTree;
-staticforward PyExtensionClass BTreeType;
+static PyTypeObject BTreeType;
+static PyTypeObject BucketType;
#define BTREE(O) ((BTree*)(O))
@@ -252,16 +247,16 @@
static PyObject *
IndexError(int i)
{
- PyObject *v;
+ PyObject *v;
- v=PyInt_FromLong(i);
- UNLESS (v) {
- v=Py_None;
- Py_INCREF(v);
- }
- PyErr_SetObject(PyExc_IndexError, v);
- Py_DECREF(v);
- return NULL;
+ v = PyInt_FromLong(i);
+ if (!v) {
+ v = Py_None;
+ Py_INCREF(v);
+ }
+ PyErr_SetObject(PyExc_IndexError, v);
+ Py_DECREF(v);
+ return NULL;
}
/* Search for the bucket immediately preceding *current, in the bucket chain
@@ -286,8 +281,7 @@
trailing = first;
PER_USE_OR_RETURN(first, -1);
first = first->next;
- PER_ALLOW_DEACTIVATION(trailing);
- PER_ACCESSED(trailing);
+ PER_UNUSE(trailing);
if (first == *current) {
*current = trailing;
@@ -300,33 +294,45 @@
}
static void *
-PyMalloc(size_t sz)
+BTree_Malloc(size_t sz)
{
- void *r;
+ void *r;
- ASSERT(sz > 0, "non-positive size malloc", NULL);
+ ASSERT(sz > 0, "non-positive size malloc", NULL);
- if ((r = malloc(sz))) return r;
+ r = malloc(sz);
+ if (r)
+ return r;
- PyErr_NoMemory();
- return NULL;
+ PyErr_NoMemory();
+ return NULL;
}
static void *
-PyRealloc(void *p, size_t sz)
+BTree_Realloc(void *p, size_t sz)
{
- void *r;
+ void *r;
- ASSERT(sz > 0, "non-positive size realloc", NULL);
+ ASSERT(sz > 0, "non-positive size realloc", NULL);
- if (p) r = realloc(p,sz);
- else r = malloc(sz);
+ if (p)
+ r = realloc(p, sz);
+ else
+ r = malloc(sz);
- UNLESS (r) PyErr_NoMemory();
+ UNLESS (r)
+ PyErr_NoMemory();
- return r;
+ return r;
}
+/* Shared keyword-argument list for BTree/Bucket
+ * (iter)?(keys|values|items)
+ */
+static char *search_keywords[] = {"min", "max",
+ "excludemin", "excludemax",
+ 0};
+
#include "BTreeItemsTemplate.c"
#include "BucketTemplate.c"
#include "SetTemplate.c"
@@ -385,81 +391,99 @@
BTREEITEMSTEMPLATE_C
;
-void
-INITMODULE (void)
+int
+init_persist_type(PyTypeObject *type)
{
- PyObject *m, *d, *c;
+ type->ob_type = &PyType_Type;
+ type->tp_base = cPersistenceCAPI->pertype;
- UNLESS (sort_str=PyString_FromString("sort")) return;
- UNLESS (reverse_str=PyString_FromString("reverse")) return;
- UNLESS (items_str=PyString_FromString("items")) return;
- UNLESS (__setstate___str=PyString_FromString("__setstate__")) return;
+ if (PyType_Ready(type) < 0)
+ return 0;
- UNLESS (PyExtensionClassCAPI=PyCObject_Import("ExtensionClass","CAPI"))
- return;
-
-#ifdef PERSISTENT
- if ((cPersistenceCAPI=PyCObject_Import("cPersistence","CAPI")))
- {
- BucketType.methods.link=cPersistenceCAPI->methods;
- BucketType.tp_getattro=cPersistenceCAPI->getattro;
- BucketType.tp_setattro=cPersistenceCAPI->setattro;
-
- SetType.methods.link=cPersistenceCAPI->methods;
- SetType.tp_getattro=cPersistenceCAPI->getattro;
- SetType.tp_setattro=cPersistenceCAPI->setattro;
-
- BTreeType.methods.link=cPersistenceCAPI->methods;
- BTreeType.tp_getattro=cPersistenceCAPI->getattro;
- BTreeType.tp_setattro=cPersistenceCAPI->setattro;
-
- TreeSetType.methods.link=cPersistenceCAPI->methods;
- TreeSetType.tp_getattro=cPersistenceCAPI->getattro;
- TreeSetType.tp_setattro=cPersistenceCAPI->setattro;
- }
- else return;
-
- /* Grab the ConflictError class */
+ return 1;
+}
- m = PyImport_ImportModule("ZODB.POSException");
+void
+INITMODULE (void)
+{
+ PyObject *m, *d, *c;
- if (m != NULL) {
+ sort_str = PyString_InternFromString("sort");
+ if (!sort_str)
+ return;
+ reverse_str = PyString_InternFromString("reverse");
+ if (!reverse_str)
+ return;
+ __setstate___str = PyString_InternFromString("__setstate__");
+ if (!__setstate___str)
+ return;
+ _bucket_type_str = PyString_InternFromString("_bucket_type");
+ if (!_bucket_type_str)
+ return;
+
+ /* Grab the ConflictError class */
+ m = PyImport_ImportModule("ZODB.POSException");
+ if (m != NULL) {
c = PyObject_GetAttrString(m, "BTreesConflictError");
if (c != NULL)
- ConflictError = c;
+ ConflictError = c;
Py_DECREF(m);
- }
+ }
- if (ConflictError == NULL) {
+ if (ConflictError == NULL) {
Py_INCREF(PyExc_ValueError);
ConflictError=PyExc_ValueError;
- }
-
-#else
- BTreeType.tp_getattro=PyExtensionClassCAPI->getattro;
- BucketType.tp_getattro=PyExtensionClassCAPI->getattro;
- SetType.tp_getattro=PyExtensionClassCAPI->getattro;
- TreeSetType.tp_getattro=PyExtensionClassCAPI->getattro;
-#endif
-
- BTreeItemsType.ob_type=&PyType_Type;
+ }
-#ifdef INTSET_H
- UNLESS(d = PyImport_ImportModule("intSet")) return;
- UNLESS(intSetType = PyObject_GetAttrString (d, "intSet")) return;
- Py_DECREF (d);
-#endif
+ /* Initialize the PyPersist_C_API and the type objects. */
+ cPersistenceCAPI = PyCObject_Import("persistent.cPersistence", "CAPI");
+ if (cPersistenceCAPI == NULL)
+ return;
+
+ BTreeItemsType.ob_type = &PyType_Type;
+ BTreeIter_Type.ob_type = &PyType_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;
+ if (!init_persist_type(&BTreeType))
+ return;
+ if (!init_persist_type(&SetType))
+ return;
+ if (!init_persist_type(&TreeSetType))
+ return;
+
+ if (PyDict_SetItem(BTreeType.tp_dict, _bucket_type_str,
+ (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;
+ }
- /* Create the module and add the functions */
- m = Py_InitModule4("_" MOD_NAME_PREFIX "BTree", module_methods,
- BTree_module_documentation,
- (PyObject*)NULL,PYTHON_API_VERSION);
-
- /* Add some symbolic constants to the module */
- d = PyModule_GetDict(m);
-
- PyExtensionClass_Export(d,MOD_NAME_PREFIX "Bucket", BucketType);
- PyExtensionClass_Export(d,MOD_NAME_PREFIX "BTree", BTreeType);
- PyExtensionClass_Export(d,MOD_NAME_PREFIX "Set", SetType);
- PyExtensionClass_Export(d,MOD_NAME_PREFIX "TreeSet", TreeSetType);
+ /* Create the module and add the functions */
+ m = Py_InitModule4("_" MOD_NAME_PREFIX "BTree",
+ module_methods, BTree_module_documentation,
+ (PyObject *)NULL, PYTHON_API_VERSION);
+
+ /* Add some symbolic constants to the module */
+ d = PyModule_GetDict(m);
+ if (PyDict_SetItemString(d, MOD_NAME_PREFIX "Bucket",
+ (PyObject *)&BucketType) < 0)
+ return;
+ if (PyDict_SetItemString(d, MOD_NAME_PREFIX "BTree",
+ (PyObject *)&BTreeType) < 0)
+ return;
+ if (PyDict_SetItemString(d, MOD_NAME_PREFIX "Set",
+ (PyObject *)&SetType) < 0)
+ return;
+ if (PyDict_SetItemString(d, MOD_NAME_PREFIX "TreeSet",
+ (PyObject *)&TreeSetType) < 0)
+ return;
}
=== Zope/lib/python/BTrees/BTreeTemplate.c 1.74 => 1.74.36.1 === (1246/1646 lines abridged)
--- Zope/lib/python/BTrees/BTreeTemplate.c:1.74 Fri Apr 11 12:09:58 2003
+++ Zope/lib/python/BTrees/BTreeTemplate.c Tue Nov 25 15:17:25 2003
@@ -145,7 +145,7 @@
* Py_None No problem found.
*/
static PyObject*
-BTree_check(BTree *self, PyObject *args)
+BTree_check(BTree *self)
{
PyObject *result = NULL;
int i = BTree_check_inner(self, NULL);
@@ -225,6 +225,30 @@
return _BTree_get(self, key, 0);
}
+/* Create a new bucket for the BTree or TreeSet using the class attribute
+ _bucket_type, which is normally initialized to BucketType or SetType
+ as appropriate.
+*/
+static Sized *
+BTree_newBucket(BTree *self)
+{
+ PyObject *factory;
+ Sized *result;
+
+ /* _bucket_type_str defined in BTreeModuleTemplate.c */
+ factory = PyObject_GetAttr((PyObject *)self->ob_type, _bucket_type_str);
+ if (factory == NULL)
+ return NULL;
+ /* XXX Should we check that the factory actually returns something
+ of the appropriate type? How? The C code here is going to
+ depend on any custom bucket type having the same layout at the
+ C level.
+ */
+ result = SIZED(PyObject_CallObject(factory, NULL));
+ Py_DECREF(factory);
+ return result;
+}
+
/*
* Move data from the current BTree, from index onward, to the newly created
* BTree 'next'. self and next must both be activated. If index is OOB (< 0
@@ -250,7 +274,7 @@
ASSERT(index > 0, "split creates empty tree", -1);
ASSERT(next_size > 0, "split creates empty tree", -1);
- next->data = PyMalloc(sizeof(BTreeItem) * next_size);
+ next->data = BTree_Malloc(sizeof(BTreeItem) * next_size);
if (!next->data)
return -1;
memcpy(next->data, self->data + index, sizeof(BTreeItem) * next_size);
@@ -269,7 +293,7 @@
next->len = next_size;
self->len = index;
- return PER_CHANGED(self) < 0 ? -1 : 0;
+ return PER_CHANGED(self) >= 0 ? 0 : -1;
}
@@ -297,7 +321,7 @@
child = BTREE(PyObject_CallObject(OBJECT(self->ob_type), NULL));
if (!child) return -1;
- d = PyMalloc(sizeof(BTreeItem) * 2);
+ d = BTree_Malloc(sizeof(BTreeItem) * 2);
if (!d) {
Py_DECREF(child);
return -1;
@@ -344,104 +368,85 @@
Sized *v, *e = 0;
BTreeItem *d;
- if (self->len == self->size)
- {
- if (self->size)
- {
- d = PyRealloc(self->data, sizeof(BTreeItem) * self->size * 2);
- if (d == NULL)
- return -1;
+ if (self->len == self->size) {
+ if (self->size) {
+ d = BTree_Realloc(self->data, sizeof(BTreeItem) * self->size * 2);
+ if (d == NULL)
+ return -1;
self->data = d;
self->size *= 2;
- }
- else
- {
- d = PyMalloc(sizeof(BTreeItem) * 2);
- if (d == NULL)
- return -1;
+ }
+ else {
+ d = BTree_Malloc(sizeof(BTreeItem) * 2);
+ if (d == NULL)
+ return -1;
self->data = d;
self->size = 2;
- }
- }
+ }
+ }
- if (self->len)
- {
+ if (self->len) {
d = self->data + index;
v = d->child;
/* Create a new object of the same type as the target value */
- e = SIZED(PyObject_CallObject(OBJECT(v->ob_type), NULL));
- UNLESS (e) return -1;
+ e = (Sized *)PyObject_CallObject((PyObject *)v->ob_type, NULL);
+ if (e == NULL)
+ return -1;
- UNLESS(PER_USE(v))
- {
+ UNLESS(PER_USE(v)) {
Py_DECREF(e);
return -1;
- }
+ }
/* Now split between the original (v) and the new (e) at the midpoint*/
if (SameType_Check(self, v))
- {
- i = BTree_split(BTREE(v), -1, BTREE(e));
- }
+ i = BTree_split((BTree *)v, -1, (BTree *)e);
else
- {
- i = bucket_split(BUCKET(v), -1, BUCKET(e));
- }
+ i = bucket_split((Bucket *)v, -1, (Bucket *)e);
PER_ALLOW_DEACTIVATION(v);
- if (i < 0)
- {
+ if (i < 0) {
Py_DECREF(e);
+ assert(PyErr_Occurred());
return -1;
- }
+ }
index++;
d++;
if (self->len > index) /* Shift up the old values one array slot */
- memmove(d+1, d, sizeof(BTreeItem)*(self->len-index));
+ memmove(d+1, d, sizeof(BTreeItem)*(self->len-index));
- if (SameType_Check(self, v))
- {
+ if (SameType_Check(self, v)) {
COPY_KEY(d->key, BTREE(e)->data->key);
/* We take the unused reference from e, so there's no
reason to INCREF!
*/
/* INCREF_KEY(self->data[1].key); */
- }
- else
- {
+ }
+ else {
COPY_KEY(d->key, BUCKET(e)->keys[0]);
INCREF_KEY(d->key);
- }
+ }
d->child = e;
-
self->len++;
if (self->len >= MAX_BTREE_SIZE(self) * 2) /* the root is huge */
- return BTree_split_root(self, noval);
- }
- else
- {
+ return BTree_split_root(self, noval);
+ }
+ else {
/* The BTree is empty. Create an empty bucket. See CAUTION in
* the comments preceding.
*/
assert(index == 0);
d = self->data;
- if (noval)
- {
- d->child = SIZED(PyObject_CallObject(OBJECT(&SetType), NULL));
- UNLESS (d->child) return -1;
- }
- else
- {
- d->child = SIZED(PyObject_CallObject(OBJECT(&BucketType), NULL));
- UNLESS (d->child) return -1;
- }
+ d->child = BTree_newBucket(self);
+ if (d->child == NULL)
[-=- -=- -=- 1246 lines omitted -=- -=- -=-]
- {"_p_deactivate", (PyCFunction) BTree__p_deactivate, METH_VARARGS,
- "_p_deactivate() -- Reinitialize from a newly created copy"},
+ {"_p_resolveConflict", (PyCFunction) BTree__p_resolveConflict,
+ METH_VARARGS,
+ "_p_resolveConflict() -- Reinitialize from a newly created copy"},
+
+ {"_p_deactivate", (PyCFunction) BTree__p_deactivate, METH_KEYWORDS,
+ "_p_deactivate()\n\nReinitialize from a newly created copy."},
#endif
- {NULL, NULL} /* sentinel */
+ {NULL, NULL}
};
+static int
+BTree_init(PyObject *self, PyObject *args, PyObject *kwds)
+{
+ PyObject *v = NULL;
+
+ if (!PyArg_ParseTuple(args, "|O:" MOD_NAME_PREFIX "BTree", &v))
+ return -1;
+
+ if (v)
+ return update_from_seq(self, v);
+ else
+ return 0;
+}
+
static void
BTree_dealloc(BTree *self)
{
- if (self->state != cPersistent_GHOST_STATE)
- _BTree_clear(self);
+ if (self->state != cPersistent_GHOST_STATE)
+ _BTree_clear(self);
+ cPersistenceCAPI->pertype->tp_dealloc((PyObject *)self);
+}
+
+static int
+BTree_traverse(BTree *self, visitproc visit, void *arg)
+{
+ int err = 0;
+ int i, len;
+
+#define VISIT(SLOT) \
+ if (SLOT) { \
+ err = visit((PyObject *)(SLOT), arg); \
+ if (err) \
+ goto Done; \
+ }
+
+ if (self->ob_type == &BTreeType)
+ assert(self->ob_type->tp_dictoffset == 0);
+
+ /* Call our base type's traverse function. Because BTrees are
+ * subclasses of Peristent, there must be one.
+ */
+ err = cPersistenceCAPI->pertype->tp_traverse((PyObject *)self, visit, arg);
+ if (err)
+ goto Done;
+
+ /* If this is registered with the persistence system, cleaning up cycles
+ * is the database's problem. It would be horrid to unghostify BTree
+ * nodes here just to chase pointers every time gc runs.
+ */
+ if (self->state == cPersistent_GHOST_STATE)
+ goto Done;
+
+ len = self->len;
+#ifdef KEY_TYPE_IS_PYOBJECT
+ /* Keys are Python objects so need to be traversed. Note that the
+ * key 0 slot is unused and should not be traversed.
+ */
+ for (i = 1; i < len; i++)
+ VISIT(self->data[i].key);
+#endif
+
+ /* Children are always pointers, and child 0 is legit. */
+ for (i = 0; i < len; i++)
+ VISIT(self->data[i].child);
- PER_DEL(self);
+ VISIT(self->firstbucket);
- Py_DECREF(self->ob_type);
- PyObject_Del(self);
+Done:
+ return err;
+
+#undef VISIT
+}
+
+static int
+BTree_tp_clear(BTree *self)
+{
+ if (self->state != cPersistent_GHOST_STATE)
+ _BTree_clear(self);
+ return 0;
}
/*
@@ -1722,8 +2011,21 @@
(objobjargproc)BTree_setitem, /*mp_ass_subscript*/
};
+static PySequenceMethods BTree_as_sequence = {
+ (inquiry)0, /* sq_length */
+ (binaryfunc)0, /* sq_concat */
+ (intargfunc)0, /* sq_repeat */
+ (intargfunc)0, /* sq_item */
+ (intintargfunc)0, /* sq_slice */
+ (intobjargproc)0, /* sq_ass_item */
+ (intintobjargproc)0, /* sq_ass_slice */
+ (objobjproc)BTree_contains, /* sq_contains */
+ 0, /* sq_inplace_concat */
+ 0, /* sq_inplace_repeat */
+};
+
static int
-BTree_nonzero( BTree *self)
+BTree_nonzero(BTree *self)
{
return BTree_length_or_nonzero(self, 1);
}
@@ -1732,35 +2034,45 @@
0,0,0,0,0,0,0,0,0,0,
(inquiry)BTree_nonzero};
-static PyExtensionClass BTreeType = {
- PyObject_HEAD_INIT(NULL)
- 0, /*ob_size*/
- MOD_NAME_PREFIX "BTree", /*tp_name*/
- sizeof(BTree), /*tp_basicsize*/
- 0, /*tp_itemsize*/
- /************* methods ********************/
- (destructor) BTree_dealloc,/*tp_dealloc*/
- (printfunc)0, /*tp_print*/
- (getattrfunc)0, /*obsolete tp_getattr*/
- (setattrfunc)0, /*obsolete tp_setattr*/
- (cmpfunc)0, /*tp_compare*/
- (reprfunc)0, /*tp_repr*/
- &BTree_as_number_for_nonzero, /*tp_as_number*/
- 0, /*tp_as_sequence*/
- &BTree_as_mapping, /*tp_as_mapping*/
- (hashfunc)0, /*tp_hash*/
- (ternaryfunc)0, /*tp_call*/
- (reprfunc)0, /*tp_str*/
- (getattrofunc)0,
- 0, /*tp_setattro*/
-
- /* Space for future expansion */
- 0L,0L,
- "Mapping type implemented as sorted list of items",
- METHOD_CHAIN(BTree_methods),
- EXTENSIONCLASS_BASICNEW_FLAG
-#ifdef PERSISTENT
- | PERSISTENT_TYPE_FLAG
-#endif
- | EXTENSIONCLASS_NOINSTDICT_FLAG,
+static PyTypeObject BTreeType = {
+ PyObject_HEAD_INIT(NULL) /* PyPersist_Type */
+ 0, /* ob_size */
+ MODULE_NAME MOD_NAME_PREFIX "BTree",/* tp_name */
+ sizeof(BTree), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ (destructor)BTree_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ 0, /* tp_repr */
+ &BTree_as_number_for_nonzero, /* tp_as_number */
+ &BTree_as_sequence, /* tp_as_sequence */
+ &BTree_as_mapping, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
+ Py_TPFLAGS_BASETYPE, /* tp_flags */
+ 0, /* tp_doc */
+ (traverseproc)BTree_traverse, /* tp_traverse */
+ (inquiry)BTree_tp_clear, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ (getiterfunc)BTree_getiter, /* tp_iter */
+ 0, /* tp_iternext */
+ BTree_methods, /* tp_methods */
+ BTree_members, /* tp_members */
+ 0, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+ 0, /* tp_dictoffset */
+ BTree_init, /* tp_init */
+ 0, /* tp_alloc */
+ 0, /*PyType_GenericNew,*/ /* tp_new */
};
=== Zope/lib/python/BTrees/BucketTemplate.c 1.54 => 1.54.32.1 === (1255/1655 lines abridged)
--- Zope/lib/python/BTrees/BucketTemplate.c:1.54 Sun May 11 20:36:17 2003
+++ Zope/lib/python/BTrees/BucketTemplate.c Tue Nov 25 15:17:25 2003
@@ -65,7 +65,7 @@
** has_key itself as a Python int. A BTree caller generally passes
** the depth of the bucket for has_key, so a true result returns
** the bucket depth then.
-** Note that has_key should be tree when searching set buckets.
+** Note that has_key should be true when searching set buckets.
** If not has_key:
** If the key is present, returns the associated value, and the
** caller owns the reference. Else returns NULL and sets KeyError.
@@ -83,7 +83,7 @@
COPY_KEY_FROM_ARG(key, keyarg, copied);
UNLESS (copied) return NULL;
- PER_USE_OR_RETURN(self, NULL);
+ UNLESS (PER_USE(self)) return NULL;
BUCKET_SEARCH(i, cmp, self, key, goto Done);
if (has_key)
@@ -97,9 +97,9 @@
}
Done:
- PER_ALLOW_DEACTIVATION(self);
- PER_ACCESSED(self);
- return r;
+ PER_UNUSE(self);
+ return r;
+
}
static PyObject *
@@ -126,49 +126,43 @@
static int
Bucket_grow(Bucket *self, int newsize, int noval)
{
- KEY_TYPE *keys;
- VALUE_TYPE *values;
+ KEY_TYPE *keys;
+ VALUE_TYPE *values;
- if (self->size)
- {
- if (newsize < 0)
- newsize = self->size * 2;
- if (newsize < 0) /* int overflow */
- goto Overflow;
- UNLESS (keys = PyRealloc(self->keys, sizeof(KEY_TYPE) * newsize))
- return -1;
+ if (self->size) {
+ if (newsize < 0)
+ newsize = self->size * 2;
+ if (newsize < 0) /* int overflow */
+ goto Overflow;
+ UNLESS (keys = BTree_Realloc(self->keys, sizeof(KEY_TYPE) * newsize))
+ return -1;
- UNLESS (noval)
- {
- values = PyRealloc(self->values, sizeof(VALUE_TYPE) * newsize);
- if (values == NULL)
- {
- free(keys);
- return -1;
+ UNLESS (noval) {
+ values = BTree_Realloc(self->values, sizeof(VALUE_TYPE) * newsize);
+ if (values == NULL) {
+ free(keys);
+ return -1;
}
- self->values = values;
+ self->values = values;
}
- self->keys = keys;
+ self->keys = keys;
}
- else
- {
- if (newsize < 0)
- newsize = MIN_BUCKET_ALLOC;
- UNLESS (self->keys = PyMalloc(sizeof(KEY_TYPE) * newsize))
- return -1;
- UNLESS (noval)
- {
- self->values = PyMalloc(sizeof(VALUE_TYPE) * newsize);
- if (self->values == NULL)
- {
- free(self->keys);
- self->keys = NULL;
- return -1;
+ else {
+ if (newsize < 0)
+ newsize = MIN_BUCKET_ALLOC;
+ UNLESS (self->keys = BTree_Malloc(sizeof(KEY_TYPE) * newsize))
+ return -1;
+ UNLESS (noval) {
+ self->values = BTree_Malloc(sizeof(VALUE_TYPE) * newsize);
+ if (self->values == NULL) {
+ free(self->keys);
+ self->keys = NULL;
+ return -1;
}
}
}
- self->size = newsize;
- return 0;
+ self->size = newsize;
+ return 0;
Overflow:
PyErr_NoMemory();
@@ -325,7 +319,7 @@
UNLESS(copied) return -1;
}
- PER_USE_OR_RETURN(self, -1);
+ UNLESS (PER_USE(self)) return -1;
BUCKET_SEARCH(i, cmp, self, key, goto Done);
if (cmp == 0) {
@@ -402,11 +396,11 @@
goto Done;
if (self->len > i) {
- memmove(self->keys + i+1, self->keys + i,
- sizeof(KEY_TYPE)*(self->len - i));
+ memmove(self->keys + i + 1, self->keys + i,
+ sizeof(KEY_TYPE) * (self->len - i));
if (self->values) {
- memmove(self->values + i+1, self->values + i,
- sizeof(VALUE_TYPE)*(self->len - i));
+ memmove(self->values + i + 1, self->values + i,
+ sizeof(VALUE_TYPE) * (self->len - i));
}
}
@@ -425,8 +419,7 @@
result = 1;
Done:
- PER_ALLOW_DEACTIVATION(self);
- PER_ACCESSED(self);
+ PER_UNUSE(self);
return result;
}
@@ -445,85 +438,78 @@
static int
bucket_setitem(Bucket *self, PyObject *key, PyObject *v)
{
- if (_bucket_set(self, key, v, 0, 0, 0) < 0) return -1;
- return 0;
+ if (_bucket_set(self, key, v, 0, 0, 0) < 0)
+ return -1;
+ return 0;
}
/**
- ** Mapping_update()
- **
- ** Accepts a sequence of 2-tuples or any object with an items()
- ** method that returns a sequence of 2-tuples.
- **
+ ** Accepts a sequence of 2-tuples, or any object with an items()
+ ** method that returns an iterable object producing 2-tuples.
*/
-
-static PyObject *
-Mapping_update(PyObject *self, PyObject *args)
+static int
+update_from_seq(PyObject *map, PyObject *seq)
{
- PyObject *seq=0, *o, *t, *v, *tb, *k, *items = NULL;
- int i;
+ PyObject *iter, *o, *k, *v;
+ int err = -1;
- UNLESS(PyArg_ParseTuple(args, "|O:update", &seq)) return NULL;
-
- if (!seq)
- {
- Py_INCREF(Py_None);
- return Py_None;
- }
-
- if (!PySequence_Check(seq))
- {
- items = PyObject_GetAttr(seq, items_str);
- UNLESS(items) return NULL;
- ASSIGN(items, PyObject_CallObject(items, NULL));
- UNLESS(items) return NULL;
- /* items is DECREFed on exit, seq is not */
- seq = items;
- }
-
- for (i=0; ; i++)
- {
- o = PySequence_GetItem(seq, i);
- UNLESS (o)
[-=- -=- -=- 1255 lines omitted -=- -=- -=-]
+#ifdef KEY_TYPE_IS_PYOBJECT
+ /* Keys are Python objects so need to be traversed. */
+ for (i = 0; i < len; i++)
+ VISIT(self->keys[i]);
+#endif
- Py_DECREF(self->ob_type);
- PyObject_Del(self);
+#ifdef VALUE_TYPE_IS_PYOBJECT
+ if (self->values != NULL) {
+ /* self->values exists (this is a mapping bucket, not a set bucket),
+ * and are Python objects, so need to be traversed. */
+ for (i = 0; i < len; i++)
+ VISIT(self->values[i]);
+ }
+#endif
+
+ VISIT(self->next);
+
+Done:
+ return err;
+
+#undef VISIT
+}
+
+static int
+bucket_tp_clear(Bucket *self)
+{
+ if (self->state != cPersistent_GHOST_STATE)
+ _bucket_clear(self);
+ return 0;
}
/* Code to access Bucket objects as mappings */
static int
Bucket_length( Bucket *self)
{
- int r;
- PER_USE_OR_RETURN(self, -1);
- r=self->len;
- PER_ALLOW_DEACTIVATION(self);
- PER_ACCESSED(self);
- return r;
+ int r;
+ UNLESS (PER_USE(self)) return -1;
+ r = self->len;
+ PER_UNUSE(self);
+ return r;
}
static PyMappingMethods Bucket_as_mapping = {
@@ -1391,58 +1590,102 @@
(objobjargproc)bucket_setitem, /*mp_ass_subscript*/
};
+static PySequenceMethods Bucket_as_sequence = {
+ (inquiry)0, /* sq_length */
+ (binaryfunc)0, /* sq_concat */
+ (intargfunc)0, /* sq_repeat */
+ (intargfunc)0, /* sq_item */
+ (intintargfunc)0, /* sq_slice */
+ (intobjargproc)0, /* sq_ass_item */
+ (intintobjargproc)0, /* sq_ass_slice */
+ (objobjproc)bucket_contains, /* sq_contains */
+ 0, /* sq_inplace_concat */
+ 0, /* sq_inplace_repeat */
+};
+
static PyObject *
bucket_repr(Bucket *self)
{
- static PyObject *format;
- PyObject *r, *t;
-
- UNLESS (format) UNLESS (format=PyString_FromString(MOD_NAME_PREFIX "Bucket(%s)"))
- return NULL;
- UNLESS (t=PyTuple_New(1)) return NULL;
- UNLESS (r=bucket_items(self,NULL)) goto err;
- PyTuple_SET_ITEM(t,0,r);
- r=t;
- ASSIGN(r,PyString_Format(format,r));
- return r;
-err:
- Py_DECREF(t);
- return NULL;
+ PyObject *i, *r;
+ char repr[10000];
+ int rv;
+
+ i = bucket_items(self, NULL, NULL);
+ if (!i)
+ return NULL;
+ r = PyObject_Repr(i);
+ Py_DECREF(i);
+ if (!r) {
+ return NULL;
+ }
+ rv = PyOS_snprintf(repr, sizeof(repr),
+ "%s(%s)", self->ob_type->tp_name,
+ PyString_AS_STRING(r));
+ if (rv > 0 && rv < sizeof(repr)) {
+ Py_DECREF(r);
+ return PyString_FromStringAndSize(repr, strlen(repr));
+ }
+ else {
+ /* The static buffer wasn't big enough */
+ int size;
+ PyObject *s;
+
+ /* 3 for the parens and the null byte */
+ size = strlen(self->ob_type->tp_name) + PyString_GET_SIZE(r) + 3;
+ s = PyString_FromStringAndSize(NULL, size);
+ if (!s) {
+ Py_DECREF(r);
+ return r;
+ }
+ PyOS_snprintf(PyString_AS_STRING(s), size,
+ "%s(%s)", self->ob_type->tp_name, PyString_AS_STRING(r));
+ Py_DECREF(r);
+ return s;
+ }
}
-static PyExtensionClass BucketType = {
- PyObject_HEAD_INIT(NULL)
- 0, /*ob_size*/
- MOD_NAME_PREFIX "Bucket", /*tp_name*/
- sizeof(Bucket), /*tp_basicsize*/
- 0, /*tp_itemsize*/
- /*********** methods ***********************/
- (destructor) Bucket_dealloc, /*tp_dealloc*/
- (printfunc)0, /*tp_print*/
- (getattrfunc)0, /*obsolete tp_getattr*/
- (setattrfunc)0, /*obsolete tp_setattr*/
- (cmpfunc)0, /*tp_compare*/
- (reprfunc) bucket_repr, /*tp_repr*/
- 0, /*tp_as_number*/
- 0, /*tp_as_sequence*/
- &Bucket_as_mapping, /*tp_as_mapping*/
- (hashfunc)0, /*tp_hash*/
- (ternaryfunc)0, /*tp_call*/
- (reprfunc)0, /*tp_str*/
- (getattrofunc)0, /*tp_getattro*/
- 0, /*tp_setattro*/
-
- /* Space for future expansion */
- 0L,0L,
- "Mapping type implemented as sorted list of items",
- METHOD_CHAIN(Bucket_methods),
- EXTENSIONCLASS_BASICNEW_FLAG
-#ifdef PERSISTENT
- | PERSISTENT_TYPE_FLAG
-#endif
- | EXTENSIONCLASS_NOINSTDICT_FLAG,
+static PyTypeObject BucketType = {
+ PyObject_HEAD_INIT(NULL) /* PyPersist_Type */
+ 0, /* ob_size */
+ MODULE_NAME MOD_NAME_PREFIX "Bucket",/* tp_name */
+ sizeof(Bucket), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ (destructor)bucket_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ (reprfunc)bucket_repr, /* tp_repr */
+ 0, /* tp_as_number */
+ &Bucket_as_sequence, /* tp_as_sequence */
+ &Bucket_as_mapping, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
+ Py_TPFLAGS_BASETYPE, /* tp_flags */
+ 0, /* tp_doc */
+ (traverseproc)bucket_traverse, /* tp_traverse */
+ (inquiry)bucket_tp_clear, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ (getiterfunc)Bucket_getiter, /* tp_iter */
+ 0, /* tp_iternext */
+ Bucket_methods, /* tp_methods */
+ Bucket_members, /* tp_members */
+ 0, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+ 0, /* tp_dictoffset */
+ Bucket_init, /* tp_init */
+ 0, /* tp_alloc */
+ 0, /*PyType_GenericNew,*/ /* tp_new */
};
-
static int
nextBucket(SetIteration *i)
=== Zope/lib/python/BTrees/IIBTree.py 1.7 => 1.7.44.1 ===
--- Zope/lib/python/BTrees/IIBTree.py:1.7 Tue Feb 18 14:05:18 2003
+++ Zope/lib/python/BTrees/IIBTree.py Tue Nov 25 15:17:25 2003
@@ -14,8 +14,3 @@
# hack to overcome dynamic-linking headache.
from _IIBTree import *
-
-# We don't really want _ names in pickles, so update all of the __module__
-# references.
-for obj in IIBucket, IIBTree, IISet, IITreeSet:
- obj.__module__ = __name__
=== Zope/lib/python/BTrees/IOBTree.py 1.7 => 1.7.44.1 ===
--- Zope/lib/python/BTrees/IOBTree.py:1.7 Tue Feb 18 14:05:18 2003
+++ Zope/lib/python/BTrees/IOBTree.py Tue Nov 25 15:17:25 2003
@@ -14,8 +14,3 @@
# hack to overcome dynamic-linking headache.
from _IOBTree import *
-
-# We don't really want _ names in pickles, so update all of the __module__
-# references.
-for obj in IOBucket, IOBTree, IOSet, IOTreeSet:
- obj.__module__ = __name__
=== Zope/lib/python/BTrees/Interfaces.py 1.18 => 1.18.122.1 ===
--- Zope/lib/python/BTrees/Interfaces.py:1.18 Tue Jun 25 18:46:42 2002
+++ Zope/lib/python/BTrees/Interfaces.py Tue Nov 25 15:17:26 2003
@@ -348,6 +348,38 @@
Note that c1 and c2 must be collections.
"""
+class IMergeIntegerKey(IMerge):
+ """IMerge-able objects with integer keys.
+
+ Concretely, this means the types in IOBTree and IIBTree.
+ """
+
+ def multiunion(seq):
+ """Return union of (zero or more) integer sets, as an integer set.
+
+ seq is a sequence of objects each convertible to an integer set.
+ These objects are convertible to an integer set:
+
+ + An integer, which is added to the union.
+
+ + A Set or TreeSet from the same module (for example, an
+ IIBTree.TreeSet for IIBTree.multiunion()). The elements of the
+ set are added to the union.
+
+ + A Bucket or BTree from the same module (for example, an
+ IOBTree.IOBTree for IOBTree.multiunion()). The keys of the
+ mapping are added to the union.
+
+ The union is returned as a Set from the same module (for example,
+ IIBTree.multiunion() returns an IIBTree.IISet).
+
+ The point to this method is that it can run much faster than
+ doing a sequence of two-input union() calls. Under the covers,
+ all the integers in all the inputs are sorted via a single
+ linear-time radix sort, then duplicates are removed in a second
+ linear-time pass.
+ """
+
###############################################################
# IMPORTANT NOTE
#
@@ -359,7 +391,10 @@
#
################################################################
-OOBTree.OOSet.__implements__=ISet
-OOBTree.OOTreeSet.__implements__=ITreeSet
-OOBTree.OOBucket.__implements__=IDictionaryIsh
-OOBTree.OOBTree.__implements__=IBTree
+# XXX Need to use the new declaration syntax once it is available
+# for Zope 2.
+
+## OOBTree.OOSet.__implements__=ISet
+## OOBTree.OOTreeSet.__implements__=ITreeSet
+## OOBTree.OOBucket.__implements__=IDictionaryIsh
+## OOBTree.OOBTree.__implements__=IBTree
=== Zope/lib/python/BTrees/Length.py 1.6 => 1.6.118.1 ===
--- Zope/lib/python/BTrees/Length.py:1.6 Wed Aug 14 17:32:23 2002
+++ Zope/lib/python/BTrees/Length.py Tue Nov 25 15:17:26 2003
@@ -12,9 +12,9 @@
#
##############################################################################
-import Persistence
+import persistent
-class Length(Persistence.Persistent):
+class Length(persistent.Persistent):
"""BTree lengths are too expensive to compute
Objects that use BTrees need to keep track of lengths themselves.
=== Zope/lib/python/BTrees/MergeTemplate.c 1.16 => 1.16.44.1 ===
--- Zope/lib/python/BTrees/MergeTemplate.c:1.16 Fri Jan 17 12:20:49 2003
+++ Zope/lib/python/BTrees/MergeTemplate.c Tue Nov 25 15:17:26 2003
@@ -21,18 +21,22 @@
static int
merge_output(Bucket *r, SetIteration *i, int mapping)
{
- if(r->len >= r->size && Bucket_grow(r, -1, ! mapping) < 0) return -1;
- COPY_KEY(r->keys[r->len], i->key);
- INCREF_KEY(r->keys[r->len]);
- if (mapping)
- {
- COPY_VALUE(r->values[r->len], i->value);
- INCREF_VALUE(r->values[r->len]);
+ if (r->len >= r->size && Bucket_grow(r, -1, !mapping) < 0)
+ return -1;
+ COPY_KEY(r->keys[r->len], i->key);
+ INCREF_KEY(r->keys[r->len]);
+ if (mapping) {
+ COPY_VALUE(r->values[r->len], i->value);
+ INCREF_VALUE(r->values[r->len]);
}
- r->len++;
- return 0;
+ r->len++;
+ return 0;
}
+/* The "reason" argument is a little integer giving "a reason" for the
+ * error. In the Zope3 codebase, these are mapped to explanatory strings
+ * via zodb/btrees/interfaces.py.
+ */
static PyObject *
merge_error(int p1, int p2, int p3, int reason)
{
@@ -40,7 +44,7 @@
UNLESS (r=Py_BuildValue("iiii", p1, p2, p3, reason)) r=Py_None;
if (ConflictError == NULL) {
- ConflictError=PyExc_ValueError;
+ ConflictError = PyExc_ValueError;
Py_INCREF(ConflictError);
}
PyErr_SetObject(ConflictError, r);
@@ -52,6 +56,33 @@
return NULL;
}
+/* It's hard to explain "the rules" for bucket_merge, in large part because
+ * any automatic conflict-resolution scheme is going to be incorrect for
+ * some endcases of *some* app. The scheme here is pretty conservative,
+ * and should be OK for most apps. It's easier to explain what the code
+ * allows than what it forbids:
+ *
+ * Leaving things alone: it's OK if both s2 and s3 leave a piece of s1
+ * alone (don't delete the key, and don't change the value).
+ *
+ * Key deletion: a transaction (s2 or s3) can delete a key (from s1), but
+ * only if the other transaction (of s2 and s3) doesn't delete the same key.
+ * However, it's not OK for s2 and s3 to, between them, end up deleting all
+ * the keys. This is a higher-level constraint, due to that the caller of
+ * bucket_merge() doesn't have enough info to unlink the resulting empty
+ * bucket from its BTree correctly.
+ *
+ * Key insertion: s2 or s3 can add a new key, provided the other transaction
+ * doesn't insert the same key. It's not OK even if they insert the same
+ * <key, value> pair.
+ *
+ * Mapping value modification: s2 or s3 can modify the value associated
+ * with a key in s1, provided the other transaction doesn't make a
+ * modification of the same key to a different value. It's OK if s2 and s3
+ * both give the same new value to the key (XXX while it's hard to be
+ * precise about why, this doesn't seem consistent with that it's *not* OK
+ * for both to add a new key mapping to the same value).
+ */
static PyObject *
bucket_merge(Bucket *s1, Bucket *s2, Bucket *s3)
{
@@ -60,28 +91,34 @@
SetIteration i1 = {0,0,0}, i2 = {0,0,0}, i3 = {0,0,0};
int cmp12, cmp13, cmp23, mapping, set;
- if (initSetIteration(&i1, OBJECT(s1), 1) < 0) goto err;
- if (initSetIteration(&i2, OBJECT(s2), 1) < 0) goto err;
- if (initSetIteration(&i3, OBJECT(s3), 1) < 0) goto err;
+ if (initSetIteration(&i1, OBJECT(s1), 1) < 0)
+ goto err;
+ if (initSetIteration(&i2, OBJECT(s2), 1) < 0)
+ goto err;
+ if (initSetIteration(&i3, OBJECT(s3), 1) < 0)
+ goto err;
mapping = i1.usesValue | i2.usesValue | i3.usesValue;
- set = ! mapping;
+ set = !mapping;
if (mapping)
- {
- UNLESS(r=BUCKET(PyObject_CallObject(OBJECT(&BucketType), NULL)))
- goto err;
- }
+ r = (Bucket *)PyObject_CallObject((PyObject *)&BucketType, NULL);
else
- {
- UNLESS(r=BUCKET(PyObject_CallObject(OBJECT(&SetType), NULL)))
- goto err;
- }
+ r = (Bucket *)PyObject_CallObject((PyObject *)&SetType, NULL);
+ if (r == NULL)
+ goto err;
- if (i1.next(&i1) < 0) goto err;
- if (i2.next(&i2) < 0) goto err;
- if (i3.next(&i3) < 0) goto err;
+ if (i1.next(&i1) < 0)
+ goto err;
+ if (i2.next(&i2) < 0)
+ goto err;
+ if (i3.next(&i3) < 0)
+ goto err;
+ /* Consult zodb/btrees/interfaces.py for the meaning of the last
+ * argument passed to merge_error().
+ */
+ /* XXX This isn't passing on errors raised by value comparisons. */
while (i1.position >= 0 && i2.position >= 0 && i3.position >= 0)
{
TEST_KEY_SET_OR(cmp12, i1.key, i2.key) goto err;
@@ -91,15 +128,15 @@
if (cmp13==0)
{
if (set || (TEST_VALUE(i1.value, i2.value) == 0))
- { /* change in i3 or all same */
+ { /* change in i3 value or all same */
if (merge_output(r, &i3, mapping) < 0) goto err;
}
else if (set || (TEST_VALUE(i1.value, i3.value) == 0))
- { /* change in i2 */
+ { /* change in i2 value */
if (merge_output(r, &i2, mapping) < 0) goto err;
}
else
- { /* conflicting changes in i2 and i3 */
+ { /* conflicting value changes in i2 and i3 */
merge_error(i1.position, i2.position, i3.position, 1);
goto err;
}
@@ -113,7 +150,7 @@
if (i3.next(&i3) < 0) goto err;
}
else if (set || (TEST_VALUE(i1.value, i2.value) == 0))
- { /* delete i3 */
+ { /* deleted in i3 */
if (i1.next(&i1) < 0) goto err;
if (i2.next(&i2) < 0) goto err;
}
@@ -131,7 +168,7 @@
if (i2.next(&i2) < 0) goto err;
}
else if (set || (TEST_VALUE(i1.value, i3.value) == 0))
- { /* delete i2 */
+ { /* deleted in i2 */
if (i1.next(&i1) < 0) goto err;
if (i3.next(&i3) < 0) goto err;
}
@@ -145,7 +182,7 @@
{ /* Both keys changed */
TEST_KEY_SET_OR(cmp23, i2.key, i3.key) goto err;
if (cmp23==0)
- { /* dualing inserts or deletes */
+ { /* dueling inserts or deletes */
merge_error(i1.position, i2.position, i3.position, 4);
goto err;
}
@@ -168,8 +205,8 @@
if (i3.next(&i3) < 0) goto err;
}
else
- { /* Dueling deletes */
- merge_error(i1.position, i2.position, i3.position, 5);
+ { /* 1<2 and 1<3: both deleted 1.key */
+ merge_error(i1.position, i2.position, i3.position, 5);
goto err;
}
}
@@ -179,7 +216,7 @@
{ /* New inserts */
TEST_KEY_SET_OR(cmp23, i2.key, i3.key) goto err;
if (cmp23==0)
- { /* dualing inserts */
+ { /* dueling inserts */
merge_error(i1.position, i2.position, i3.position, 6);
goto err;
}
@@ -196,7 +233,7 @@
}
while (i1.position >= 0 && i2.position >= 0)
- { /* deleting i3 */
+ { /* remainder of i1 deleted in i3 */
TEST_KEY_SET_OR(cmp12, i1.key, i2.key) goto err;
if (cmp12 > 0)
{ /* insert i2 */
@@ -209,14 +246,14 @@
if (i2.next(&i2) < 0) goto err;
}
else
- { /* Dualing deletes or delete and change */
+ { /* Dueling deletes or delete and change */
merge_error(i1.position, i2.position, i3.position, 7);
goto err;
}
}
while (i1.position >= 0 && i3.position >= 0)
- { /* deleting i2 */
+ { /* remainder of i1 deleted in i2 */
TEST_KEY_SET_OR(cmp13, i1.key, i3.key) goto err;
if (cmp13 > 0)
{ /* insert i3 */
@@ -229,7 +266,7 @@
if (i3.next(&i3) < 0) goto err;
}
else
- { /* Dualing deletes or delete and change */
+ { /* Dueling deletes or delete and change */
merge_error(i1.position, i2.position, i3.position, 8);
goto err;
}
@@ -248,7 +285,7 @@
}
while (i3.position >= 0)
- { /* Inserting i2 at end */
+ { /* Inserting i3 at end */
if (merge_output(r, &i3, mapping) < 0) goto err;
if (i3.next(&i3) < 0) goto err;
}
@@ -271,7 +308,7 @@
Py_INCREF(s1->next);
r->next = s1->next;
}
- s=bucket_getstate(r, NULL);
+ s = bucket_getstate(r);
Py_DECREF(r);
return s;
=== Zope/lib/python/BTrees/OIBTree.py 1.8 => 1.8.44.1 ===
--- Zope/lib/python/BTrees/OIBTree.py:1.8 Tue Feb 18 14:05:18 2003
+++ Zope/lib/python/BTrees/OIBTree.py Tue Nov 25 15:17:26 2003
@@ -14,8 +14,3 @@
# hack to overcome dynamic-linking headache.
from _OIBTree import *
-
-# We don't really want _ names in pickles, so update all of the __module__
-# references.
-for obj in OIBucket, OIBTree, OISet, OITreeSet:
- obj.__module__ = __name__
=== Zope/lib/python/BTrees/OOBTree.py 1.8 => 1.8.44.1 ===
--- Zope/lib/python/BTrees/OOBTree.py:1.8 Tue Feb 18 14:05:18 2003
+++ Zope/lib/python/BTrees/OOBTree.py Tue Nov 25 15:17:26 2003
@@ -14,8 +14,3 @@
# hack to overcome dynamic-linking headache.
from _OOBTree import *
-
-# We don't really want _ names in pickles, so update all of the __module__
-# references.
-for obj in OOBucket, OOBTree, OOSet, OOTreeSet:
- obj.__module__ = __name__
=== Zope/lib/python/BTrees/SetOpTemplate.c 1.29 => 1.29.122.1 ===
--- Zope/lib/python/BTrees/SetOpTemplate.c:1.29 Thu Jun 27 18:24:16 2002
+++ Zope/lib/python/BTrees/SetOpTemplate.c Tue Nov 25 15:17:26 2003
@@ -18,33 +18,6 @@
#define SETOPTEMPLATE_C "$Id$\n"
-#ifdef INTSET_H
-static int
-nextIntSet(SetIteration *i)
-{
- if (i->position >= 0)
- {
- UNLESS(PER_USE(INTSET(i->set))) return -1;
-
- if (i->position < INTSET(i->set)->len)
- {
- i->key = INTSET(i->set)->data[i->position];
- i->position ++;
- }
- else
- {
- i->position = -1;
- PER_ACCESSED(INTSET(i->set));
- }
-
- PER_ALLOW_DEACTIVATION(INTSET(i->set));
- }
-
-
- return 0;
-}
-#endif
-
#ifdef KEY_CHECK
static int
nextKeyAsSet(SetIteration *i)
@@ -103,7 +76,7 @@
i->position = -1; /* set to 0 only on normal return */
i->usesValue = 0; /* assume it's a set or that values aren't iterated */
- if (ExtensionClassSubclassInstance_Check(s, &BucketType))
+ if (PyObject_IsInstance(s, (PyObject *)&BucketType))
{
i->set = s;
Py_INCREF(s);
@@ -116,15 +89,15 @@
else
i->next = nextSet;
}
- else if (ExtensionClassSubclassInstance_Check(s, &SetType))
+ else if (PyObject_IsInstance(s, (PyObject *)&SetType))
{
i->set = s;
Py_INCREF(s);
i->next = nextSet;
}
- else if (ExtensionClassSubclassInstance_Check(s, &BTreeType))
+ else if (PyObject_IsInstance(s, (PyObject *)&BTreeType))
{
- i->set = BTree_rangeSearch(BTREE(s), NULL, 'i');
+ i->set = BTree_rangeSearch(BTREE(s), NULL, NULL, 'i');
UNLESS(i->set) return -1;
if (useValues)
@@ -135,20 +108,12 @@
else
i->next = nextTreeSetItems;
}
- else if (ExtensionClassSubclassInstance_Check(s, &TreeSetType))
+ else if (PyObject_IsInstance(s, (PyObject *)&TreeSetType))
{
- i->set = BTree_rangeSearch(BTREE(s), NULL, 'k');
+ i->set = BTree_rangeSearch(BTREE(s), NULL, NULL, 'k');
UNLESS(i->set) return -1;
i->next = nextTreeSetItems;
}
-#ifdef INTSET_H
- else if (s->ob_type == (PyTypeObject*)intSetType)
- {
- i->set = s;
- Py_INCREF(s);
- i->next = nextIntSet;
- }
-#endif
#ifdef KEY_CHECK
else if (KEY_CHECK(s))
{
@@ -244,7 +209,7 @@
#ifndef MERGE
if (c12 && i1.usesValue && i2.usesValue) goto invalid_set_operation;
#endif
- if (! i1.usesValue && i2.usesValue)
+ if (! i1.usesValue&& i2.usesValue)
{
SetIteration t;
int i;
@@ -339,6 +304,7 @@
if(c1 && copyRemaining(r, &i1, merge, w1) < 0) goto err;
if(c2 && copyRemaining(r, &i2, merge, w2) < 0) goto err;
+
finiSetIteration(&i1);
finiSetIteration(&i2);
@@ -383,7 +349,7 @@
UNLESS(PyArg_ParseTuple(args, "OO", &o1, &o2)) return NULL;
- if (o1==Py_None)
+ if (o1 == Py_None)
{
Py_INCREF(o2);
return o2;
@@ -552,5 +518,4 @@
finiSetIteration(&setiter);
return NULL;
}
-
#endif
=== Zope/lib/python/BTrees/SetTemplate.c 1.16 => 1.16.78.1 ===
--- Zope/lib/python/BTrees/SetTemplate.c:1.16 Fri Oct 4 20:39:57 2002
+++ Zope/lib/python/BTrees/SetTemplate.c Tue Nov 25 15:17:26 2003
@@ -2,14 +2,14 @@
Copyright (c) 2001, 2002 Zope Corporation and Contributors.
All Rights Reserved.
-
+
This software is subject to the provisions of the Zope Public License,
Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution.
THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
FOR A PARTICULAR PURPOSE
-
+
****************************************************************************/
#define SETTEMPLATE_C "$Id$\n"
@@ -25,39 +25,64 @@
return PyInt_FromLong(i);
}
+/* _Set_update and _TreeSet_update are identical except for the
+ function they call to add the element to the set.
+*/
+
+static int
+_Set_update(Bucket *self, PyObject *seq)
+{
+ int n = -1;
+ PyObject *iter, *v;
+ int ind;
+
+ iter = PyObject_GetIter(seq);
+ if (iter == NULL)
+ return -1;
+
+ while (1) {
+ v = PyIter_Next(iter);
+ if (v == NULL) {
+ if (PyErr_Occurred())
+ goto err;
+ else
+ break;
+ }
+ ind = _bucket_set(self, v, Py_None, 1, 1, 0);
+ Py_DECREF(v);
+ if (ind < 0)
+ goto err;
+ else
+ n += ind;
+ }
+ /* n starts out at -1, which is the error return value. If
+ this point is reached, then there is no error. n must be
+ incremented to account for the initial value of -1 instead of
+ 0.
+ */
+ n++;
+
+ err:
+ Py_DECREF(iter);
+ return n;
+}
+
static PyObject *
Set_update(Bucket *self, PyObject *args)
{
- PyObject *seq=0, *o, *t, *v, *tb;
- int i, n=0, ind;
+ PyObject *seq = NULL;
+ int n = 0;
- UNLESS(PyArg_ParseTuple(args, "|O:update", &seq)) return NULL;
+ if (!PyArg_ParseTuple(args, "|O:update", &seq))
+ return NULL;
- if (seq)
- {
- for (i=0; ; i++)
- {
- UNLESS (o=PySequence_GetItem(seq, i))
- {
- PyErr_Fetch(&t, &v, &tb);
- if (t != PyExc_IndexError)
- {
- PyErr_Restore(t, v, tb);
- return NULL;
- }
- Py_XDECREF(t);
- Py_XDECREF(v);
- Py_XDECREF(tb);
- break;
- }
- ind=_bucket_set(self, o, Py_None, 1, 1, 0);
- Py_DECREF(o);
- if (ind < 0) return NULL;
- n += ind;
- }
+ if (seq) {
+ n = _Set_update(self, seq);
+ if (n < 0)
+ return NULL;
}
- return PyInt_FromLong(n);
+ return PyInt_FromLong(n);
}
static PyObject *
@@ -96,14 +121,14 @@
Py_DECREF(self->next);
self->next=0;
}
-
+
if (l > self->size)
{
- UNLESS (keys=PyRealloc(self->keys, sizeof(KEY_TYPE)*l)) return -1;
+ UNLESS (keys=BTree_Realloc(self->keys, sizeof(KEY_TYPE)*l)) return -1;
self->keys=keys;
self->size=l;
}
-
+
for (i=0; i<l; i++)
{
k=PyTuple_GET_ITEM(items, i);
@@ -130,10 +155,9 @@
UNLESS (PyArg_ParseTuple(args, "O", &args)) return NULL;
- PER_PREVENT_DEACTIVATION(self);
+ PER_PREVENT_DEACTIVATION(self);
r=_set_setstate(self, args);
- PER_ALLOW_DEACTIVATION(self);
- PER_ACCESSED(self);
+ PER_UNUSE(self);
if (r < 0) return NULL;
Py_INCREF(Py_None);
@@ -143,51 +167,76 @@
static struct PyMethodDef Set_methods[] = {
{"__getstate__", (PyCFunction) bucket_getstate, METH_VARARGS,
"__getstate__() -- Return the picklable state of the object"},
+
{"__setstate__", (PyCFunction) set_setstate, METH_VARARGS,
"__setstate__() -- Set the state of the object"},
- {"keys", (PyCFunction) bucket_keys, METH_VARARGS,
+
+ {"keys", (PyCFunction) bucket_keys, METH_KEYWORDS,
"keys() -- Return the keys"},
- {"has_key", (PyCFunction) bucket_has_key, METH_VARARGS,
+
+ {"has_key", (PyCFunction) bucket_has_key, METH_O,
"has_key(key) -- Test whether the bucket contains the given key"},
+
{"clear", (PyCFunction) bucket_clear, METH_VARARGS,
"clear() -- Remove all of the items from the bucket"},
+
{"maxKey", (PyCFunction) Bucket_maxKey, METH_VARARGS,
"maxKey([key]) -- Find the maximum key\n\n"
"If an argument is given, find the maximum <= the argument"},
+
{"minKey", (PyCFunction) Bucket_minKey, METH_VARARGS,
"minKey([key]) -- Find the minimum key\n\n"
"If an argument is given, find the minimum >= the argument"},
+
#ifdef PERSISTENT
{"_p_resolveConflict", (PyCFunction) bucket__p_resolveConflict, METH_VARARGS,
"_p_resolveConflict() -- Reinitialize from a newly created copy"},
- {"_p_deactivate", (PyCFunction) bucket__p_deactivate, METH_VARARGS,
+
+ {"_p_deactivate", (PyCFunction) bucket__p_deactivate, METH_KEYWORDS,
"_p_deactivate() -- Reinitialize from a newly created copy"},
#endif
+
{"insert", (PyCFunction)Set_insert, METH_VARARGS,
"insert(id,[ignored]) -- Add a key to the set"},
+
{"update", (PyCFunction)Set_update, METH_VARARGS,
"update(seq) -- Add the items from the given sequence to the set"},
- {"__init__", (PyCFunction)Set_update, METH_VARARGS,
- "__init__(seq) -- Initialize with the items from the given sequence"},
+
{"remove", (PyCFunction)Set_remove, METH_VARARGS,
"remove(id) -- Remove an id from the set"},
{NULL, NULL} /* sentinel */
};
+static int
+Set_init(PyObject *self, PyObject *args, PyObject *kwds)
+{
+ PyObject *v = NULL;
+
+ if (!PyArg_ParseTuple(args, "|O:" MOD_NAME_PREFIX "Set", &v))
+ return -1;
+
+ if (v)
+ return _Set_update((Bucket *)self, v);
+ else
+ return 0;
+}
+
+
+
static PyObject *
set_repr(Bucket *self)
{
static PyObject *format;
PyObject *r, *t;
- UNLESS (format) UNLESS (format=PyString_FromString(MOD_NAME_PREFIX "Set(%s)"))
- return NULL;
- UNLESS (t=PyTuple_New(1)) return NULL;
- UNLESS (r=bucket_keys(self,NULL)) goto err;
- PyTuple_SET_ITEM(t,0,r);
- r=t;
- ASSIGN(r,PyString_Format(format,r));
+ if (!format)
+ format = PyString_FromString(MOD_NAME_PREFIX "Set(%s)");
+ UNLESS (t = PyTuple_New(1)) return NULL;
+ UNLESS (r = bucket_keys(self, NULL, NULL)) goto err;
+ PyTuple_SET_ITEM(t, 0, r);
+ r = t;
+ ASSIGN(r, PyString_Format(format, r));
return r;
err:
Py_DECREF(t);
@@ -195,14 +244,13 @@
}
static int
-set_length(Bucket *self)
+set_length(Bucket *self)
{
int r;
PER_USE_OR_RETURN(self, -1);
r = self->len;
- PER_ALLOW_DEACTIVATION(self);
- PER_ACCESSED(self);
+ PER_UNUSE(self);
return r;
}
@@ -220,59 +268,71 @@
else
IndexError(index);
- PER_ALLOW_DEACTIVATION(self);
- PER_ACCESSED(self);
+ PER_UNUSE(self);
return r;
}
static PySequenceMethods set_as_sequence = {
- (inquiry)set_length, /*sq_length*/
- (binaryfunc)0, /*sq_concat*/
- (intargfunc)0, /*sq_repeat*/
- (intargfunc)set_item, /*sq_item*/
- (intintargfunc)0, /*sq_slice*/
- (intobjargproc)0, /*sq_ass_item*/
- (intintobjargproc)0, /*sq_ass_slice*/
+ (inquiry)set_length, /* sq_length */
+ (binaryfunc)0, /* sq_concat */
+ (intargfunc)0, /* sq_repeat */
+ (intargfunc)set_item, /* sq_item */
+ (intintargfunc)0, /* sq_slice */
+ (intobjargproc)0, /* sq_ass_item */
+ (intintobjargproc)0, /* sq_ass_slice */
+ (objobjproc)bucket_contains, /* sq_contains */
+ 0, /* sq_inplace_concat */
+ 0, /* sq_inplace_repeat */
};
-static PyExtensionClass SetType = {
- PyObject_HEAD_INIT(NULL)
- 0, /*ob_size*/
- MOD_NAME_PREFIX "Set", /*tp_name*/
- sizeof(Bucket), /*tp_basicsize*/
- 0, /*tp_itemsize*/
- /*********** methods ***********************/
- (destructor) Bucket_dealloc, /*tp_dealloc*/
- (printfunc)0, /*tp_print*/
- (getattrfunc)0, /*obsolete tp_getattr*/
- (setattrfunc)0, /*obsolete tp_setattr*/
- (cmpfunc)0, /*tp_compare*/
- (reprfunc) set_repr, /*tp_repr*/
- 0, /*tp_as_number*/
- &set_as_sequence, /*tp_as_sequence*/
- 0, /*tp_as_mapping*/
- (hashfunc)0, /*tp_hash*/
- (ternaryfunc)0, /*tp_call*/
- (reprfunc)0, /*tp_str*/
- (getattrofunc)0, /*tp_getattro*/
- 0, /*tp_setattro*/
-
- /* Space for future expansion */
- 0L,0L,
- "Set implemented as sorted keys",
- METHOD_CHAIN(Set_methods),
- EXTENSIONCLASS_BASICNEW_FLAG
-#ifdef PERSISTENT
- | PERSISTENT_TYPE_FLAG
-#endif
- | EXTENSIONCLASS_NOINSTDICT_FLAG,
+static PyTypeObject SetType = {
+ PyObject_HEAD_INIT(NULL) /* PyPersist_Type */
+ 0, /* ob_size */
+ MODULE_NAME MOD_NAME_PREFIX "Set", /* tp_name */
+ sizeof(Bucket), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ (destructor)bucket_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ (reprfunc)set_repr, /* tp_repr */
+ 0, /* tp_as_number */
+ &set_as_sequence, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
+ Py_TPFLAGS_BASETYPE, /* tp_flags */
+ 0, /* tp_doc */
+ (traverseproc)bucket_traverse, /* tp_traverse */
+ (inquiry)bucket_tp_clear, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ (getiterfunc)Bucket_getiter, /* tp_iter */
+ 0, /* tp_iternext */
+ Set_methods, /* tp_methods */
+ Bucket_members, /* tp_members */
+ 0, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+ 0, /* tp_dictoffset */
+ Set_init, /* tp_init */
+ 0, /* tp_alloc */
+ 0, /*PyType_GenericNew,*/ /* tp_new */
};
-static int
+static int
nextSet(SetIteration *i)
{
-
+
if (i->position >= 0)
{
UNLESS(PER_USE(BUCKET(i->set))) return -1;
@@ -297,6 +357,6 @@
PER_ALLOW_DEACTIVATION(BUCKET(i->set));
}
-
+
return 0;
}
=== Zope/lib/python/BTrees/TreeSetTemplate.c 1.15 => 1.15.78.1 ===
--- Zope/lib/python/BTrees/TreeSetTemplate.c:1.15 Fri Oct 4 20:39:57 2002
+++ Zope/lib/python/BTrees/TreeSetTemplate.c Tue Nov 25 15:17:26 2003
@@ -17,47 +17,75 @@
static PyObject *
TreeSet_insert(BTree *self, PyObject *args)
{
- PyObject *key;
- int i;
+ PyObject *key;
+ int i;
- UNLESS (PyArg_ParseTuple(args, "O", &key)) return NULL;
- if ((i=_BTree_set(self, key, Py_None, 1, 1)) < 0) return NULL;
- return PyInt_FromLong(i);
+ if (!PyArg_ParseTuple(args, "O:insert", &key))
+ return NULL;
+ i = _BTree_set(self, key, Py_None, 1, 1);
+ if (i < 0)
+ return NULL;
+ return PyInt_FromLong(i);
+}
+
+/* _Set_update and _TreeSet_update are identical except for the
+ function they call to add the element to the set.
+*/
+
+static int
+_TreeSet_update(BTree *self, PyObject *seq)
+{
+ int n = -1;
+ PyObject *iter, *v;
+ int ind;
+
+ iter = PyObject_GetIter(seq);
+ if (iter == NULL)
+ return -1;
+
+ while (1) {
+ v = PyIter_Next(iter);
+ if (v == NULL) {
+ if (PyErr_Occurred())
+ goto err;
+ else
+ break;
+ }
+ ind = _BTree_set(self, v, Py_None, 1, 1);
+ Py_DECREF(v);
+ if (ind < 0)
+ goto err;
+ else
+ n += ind;
+ }
+ /* n starts out at -1, which is the error return value. If
+ this point is reached, then there is no error. n must be
+ incremented to account for the initial value of -1 instead of
+ 0.
+ */
+ n++;
+
+ err:
+ Py_DECREF(iter);
+ return n;
}
static PyObject *
TreeSet_update(BTree *self, PyObject *args)
{
- PyObject *seq=0, *o, *t, *v, *tb;
- int i, n=0, ind;
+ PyObject *seq = NULL;
+ int n = 0;
- UNLESS(PyArg_ParseTuple(args, "|O:update", &seq)) return NULL;
+ if (!PyArg_ParseTuple(args, "|O:update", &seq))
+ return NULL;
- if (seq)
- {
- for (i=0; ; i++)
- {
- UNLESS (o=PySequence_GetItem(seq, i))
- {
- PyErr_Fetch(&t, &v, &tb);
- if (t != PyExc_IndexError)
- {
- PyErr_Restore(t, v, tb);
- return NULL;
- }
- Py_XDECREF(t);
- Py_XDECREF(v);
- Py_XDECREF(tb);
- break;
- }
- ind=_BTree_set(self, o, Py_None, 1, 1);
- Py_DECREF(o);
- if (ind < 0) return NULL;
- n += ind;
- }
+ if (seq) {
+ n = _TreeSet_update(self, seq);
+ if (n < 0)
+ return NULL;
}
- return PyInt_FromLong(n);
+ return PyInt_FromLong(n);
}
@@ -81,8 +109,7 @@
PER_PREVENT_DEACTIVATION(self);
r=_BTree_setstate(self, args, 1);
- PER_ALLOW_DEACTIVATION(self);
- PER_ACCESSED(self);
+ PER_UNUSE(self);
if (r < 0) return NULL;
Py_INCREF(Py_None);
@@ -90,37 +117,54 @@
}
static struct PyMethodDef TreeSet_methods[] = {
- {"__getstate__", (PyCFunction) BTree_getstate, METH_VARARGS,
- "__getstate__() -- Return the picklable state of the object"},
+ {"__getstate__", (PyCFunction) BTree_getstate, METH_NOARGS,
+ "__getstate__() -> state\n\n"
+ "Return the picklable state of the TreeSet."},
+
{"__setstate__", (PyCFunction) TreeSet_setstate, METH_VARARGS,
- "__setstate__() -- Set the state of the object"},
- {"has_key", (PyCFunction) BTree_has_key, METH_VARARGS,
- "has_key(key) -- Test whether the bucket contains the given key"},
- {"keys", (PyCFunction) BTree_keys, METH_VARARGS,
- "keys() -- Return the keys"},
+ "__setstate__(state)\n\n"
+ "Set the state of the TreeSet."},
+
+ {"has_key", (PyCFunction) BTree_has_key, METH_O,
+ "has_key(key)\n\n"
+ "Return true if the TreeSet contains the given key."},
+
+ {"keys", (PyCFunction) BTree_keys, METH_KEYWORDS,
+ "keys([min, max]) -> list of keys\n\n"
+ "Returns the keys of the TreeSet. If min and max are supplied, only\n"
+ "keys greater than min and less than max are returned."},
+
{"maxKey", (PyCFunction) BTree_maxKey, METH_VARARGS,
- "maxKey([key]) -- Find the maximum key\n\n"
- "If an argument is given, find the maximum <= the argument"},
+ "maxKey([max]) -> key\n\n"
+ "Return the largest key in the BTree. If max is specified, return\n"
+ "the largest key <= max."},
+
{"minKey", (PyCFunction) BTree_minKey, METH_VARARGS,
- "minKey([key]) -- Find the minimum key\n\n"
- "If an argument is given, find the minimum >= the argument"},
- {"clear", (PyCFunction) BTree_clear, METH_VARARGS,
- "clear() -- Remove all of the items from the BTree"},
+ "minKey([mi]) -> key\n\n"
+ "Return the smallest key in the BTree. If min is specified, return\n"
+ "the smallest key >= min."},
+
+ {"clear", (PyCFunction) BTree_clear, METH_NOARGS,
+ "clear()\n\nRemove all of the items from the BTree."},
+
{"insert", (PyCFunction)TreeSet_insert, METH_VARARGS,
"insert(id,[ignored]) -- Add an id to the set"},
+
{"update", (PyCFunction)TreeSet_update, METH_VARARGS,
- "update(seq) -- Add the items from the given sequence to the set"},
- {"__init__", (PyCFunction)TreeSet_update, METH_VARARGS,
- "__init__(seq) -- Initialize with the items from the given sequence"},
+ "update(collection)\n\n Add the items from the given collection."},
+
{"remove", (PyCFunction)TreeSet_remove, METH_VARARGS,
"remove(id) -- Remove a key from the set"},
- {"_check", (PyCFunction) BTree_check, METH_VARARGS,
+
+ {"_check", (PyCFunction) BTree_check, METH_NOARGS,
"Perform sanity check on TreeSet, and raise exception if flawed."},
+
#ifdef PERSISTENT
{"_p_resolveConflict", (PyCFunction) BTree__p_resolveConflict, METH_VARARGS,
"_p_resolveConflict() -- Reinitialize from a newly created copy"},
- {"_p_deactivate", (PyCFunction) BTree__p_deactivate, METH_VARARGS,
- "_p_deactivate() -- Reinitialize from a newly created copy"},
+
+ {"_p_deactivate", (PyCFunction) BTree__p_deactivate, METH_KEYWORDS,
+ "_p_deactivate()\n\nReinitialize from a newly created copy."},
#endif
{NULL, NULL} /* sentinel */
};
@@ -129,35 +173,72 @@
(inquiry)BTree_length, /*mp_length*/
};
-static PyExtensionClass TreeSetType = {
- PyObject_HEAD_INIT(NULL)
- 0, /*ob_size*/
- MOD_NAME_PREFIX "TreeSet", /*tp_name*/
- sizeof(BTree), /*tp_basicsize*/
- 0, /*tp_itemsize*/
- /************* methods ********************/
- (destructor) BTree_dealloc, /*tp_dealloc*/
- (printfunc)0, /*tp_print*/
- (getattrfunc)0, /*obsolete tp_getattr*/
- (setattrfunc)0, /*obsolete tp_setattr*/
- (cmpfunc)0, /*tp_compare*/
- (reprfunc)0, /*tp_repr*/
- &BTree_as_number_for_nonzero, /*tp_as_number*/
- 0, /*tp_as_sequence*/
- &TreeSet_as_mapping, /*tp_as_mapping*/
- (hashfunc)0, /*tp_hash*/
- (ternaryfunc)0, /*tp_call*/
- (reprfunc)0, /*tp_str*/
- (getattrofunc)0,
- 0, /*tp_setattro*/
-
- /* Space for future expansion */
- 0L,0L,
- "Set implemented as sorted tree of items",
- METHOD_CHAIN(TreeSet_methods),
- EXTENSIONCLASS_BASICNEW_FLAG
-#ifdef PERSISTENT
- | PERSISTENT_TYPE_FLAG
-#endif
- | EXTENSIONCLASS_NOINSTDICT_FLAG,
+static PySequenceMethods TreeSet_as_sequence = {
+ (inquiry)0, /* sq_length */
+ (binaryfunc)0, /* sq_concat */
+ (intargfunc)0, /* sq_repeat */
+ (intargfunc)0, /* sq_item */
+ (intintargfunc)0, /* sq_slice */
+ (intobjargproc)0, /* sq_ass_item */
+ (intintobjargproc)0, /* sq_ass_slice */
+ (objobjproc)BTree_contains, /* sq_contains */
+ 0, /* sq_inplace_concat */
+ 0, /* sq_inplace_repeat */
+};
+
+static int
+TreeSet_init(PyObject *self, PyObject *args, PyObject *kwds)
+{
+ PyObject *v = NULL;
+
+ if (!PyArg_ParseTuple(args, "|O:" MOD_NAME_PREFIX "TreeSet", &v))
+ return -1;
+
+ if (v)
+ return _TreeSet_update((BTree *)self, v);
+ else
+ return 0;
+}
+
+static PyTypeObject TreeSetType = {
+ PyObject_HEAD_INIT(NULL) /* PyPersist_Type */
+ 0, /* ob_size */
+ MODULE_NAME MOD_NAME_PREFIX "TreeSet",/* tp_name */
+ sizeof(BTree), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ (destructor)BTree_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ 0, /* tp_repr */
+ &BTree_as_number_for_nonzero, /* tp_as_number */
+ &TreeSet_as_sequence, /* tp_as_sequence */
+ &TreeSet_as_mapping, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
+ Py_TPFLAGS_BASETYPE, /* tp_flags */
+ 0, /* tp_doc */
+ (traverseproc)BTree_traverse, /* tp_traverse */
+ (inquiry)BTree_tp_clear, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ (getiterfunc)BTree_getiter, /* tp_iter */
+ 0, /* tp_iternext */
+ TreeSet_methods, /* tp_methods */
+ BTree_members, /* tp_members */
+ 0, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+ 0, /* tp_dictoffset */
+ TreeSet_init, /* tp_init */
+ 0, /* tp_alloc */
+ 0, /*PyType_GenericNew,*/ /* tp_new */
};
=== Zope/lib/python/BTrees/_IIBTree.c 1.7 => 1.7.122.1 ===
--- Zope/lib/python/BTrees/_IIBTree.c:1.7 Mon Jun 24 22:00:55 2002
+++ Zope/lib/python/BTrees/_IIBTree.c Tue Nov 25 15:17:26 2003
@@ -11,8 +11,4 @@
#include "intkeymacros.h"
#include "intvaluemacros.h"
-#include "cPersistence.h"
-#ifndef EXCLUDE_INTSET_SUPPORT
-#include "BTree/intSet.h"
-#endif
#include "BTreeModuleTemplate.c"
=== Zope/lib/python/BTrees/_IOBTree.c 1.5 => 1.5.180.1 ===
--- Zope/lib/python/BTrees/_IOBTree.c:1.5 Thu Feb 21 16:41:17 2002
+++ Zope/lib/python/BTrees/_IOBTree.c Tue Nov 25 15:17:26 2003
@@ -10,8 +10,4 @@
#include "intkeymacros.h"
#include "objectvaluemacros.h"
-#include "cPersistence.h"
-#ifndef EXCLUDE_INTSET_SUPPORT
-#include "BTree/intSet.h"
-#endif
#include "BTreeModuleTemplate.c"
=== Zope/lib/python/BTrees/_OIBTree.c 1.2 => 1.2.298.1 ===
=== Zope/lib/python/BTrees/_OOBTree.c 1.2 => 1.2.298.1 ===
=== Zope/lib/python/BTrees/__init__.py 1.5 => 1.5.180.1 ===
--- Zope/lib/python/BTrees/__init__.py:1.5 Thu Feb 21 16:41:17 2002
+++ Zope/lib/python/BTrees/__init__.py Tue Nov 25 15:17:26 2003
@@ -1,12 +1,15 @@
-import ZODB
-
-try: import intSet
-except: pass
-else: del intSet
+try:
+ import intSet
+except:
+ pass
+else:
+ del intSet
# Register interfaces
-try: import Interface
-except ImportError: pass # Don't register interfaces if no scarecrow
+try:
+ import Interface
+except ImportError:
+ pass # Don't register interfaces if no scarecrow
else:
import Interfaces
del Interfaces
=== Zope/lib/python/BTrees/_fsBTree.c 1.7 => 1.7.12.1 ===
--- Zope/lib/python/BTrees/_fsBTree.c:1.7 Wed Sep 3 13:14:25 2003
+++ Zope/lib/python/BTrees/_fsBTree.c Tue Nov 25 15:17:26 2003
@@ -10,7 +10,6 @@
typedef unsigned char char2[2];
typedef unsigned char char6[6];
-
/* Setup template macros */
#define MASTER_ID "$Id$\n"
@@ -21,7 +20,7 @@
#define INITMODULE init_fsBTree
#define DEFAULT_MAX_BUCKET_SIZE 500
#define DEFAULT_MAX_BTREE_SIZE 500
-
+
/*#include "intkeymacros.h"*/
#define KEYMACROS_H "$Id$\n"
@@ -36,14 +35,13 @@
#define COPY_KEY_FROM_ARG(TARGET, ARG, STATUS) \
if (KEY_CHECK(ARG)) memcpy(TARGET, PyString_AS_STRING(ARG), 2); else { \
PyErr_SetString(PyExc_TypeError, "expected two-character string key"); \
- (STATUS)=0; }
+ (STATUS)=0; }
/*#include "intvaluemacros.h"*/
#define VALUEMACROS_H "$Id$\n"
#define VALUE_TYPE char6
#undef VALUE_TYPE_IS_PYOBJECT
#define TEST_VALUE(K, T) memcmp(K,T,6)
-#define DECLARE_VALUE(NAME) VALUE_TYPE NAME
#define DECREF_VALUE(k)
#define INCREF_VALUE(k)
#define COPY_VALUE(V, E) (memcpy(V, E, 6))
@@ -52,7 +50,7 @@
if ((PyString_Check(ARG) && PyString_GET_SIZE(ARG)==6)) \
memcpy(TARGET, PyString_AS_STRING(ARG), 6); else { \
PyErr_SetString(PyExc_TypeError, "expected six-character string key"); \
- (STATUS)=0; }
-
+ (STATUS)=0; }
+
#define NORMALIZE_VALUE(V, MIN)
#include "BTreeModuleTemplate.c"
=== Zope/lib/python/BTrees/sorters.c 1.4 => 1.4.124.1 ===
More information about the Zodb-checkins
mailing list