Recorded merge of revisions 81029 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r81029 | antoine.pitrou | 2010-05-09 16:46:46 +0200 (dim., 09 mai 2010) | 3 lines
Untabify C files. Will watch buildbots.
........
diff --git a/Modules/bsddbmodule.c b/Modules/bsddbmodule.c
index 0972882..5fd4fb1 100644
--- a/Modules/bsddbmodule.c
+++ b/Modules/bsddbmodule.c
@@ -30,12 +30,12 @@
(it messes up the info required in the Setup file) */
typedef struct {
- PyObject_HEAD
- DB *di_bsddb;
- int di_size; /* -1 means recompute */
- int di_type;
+ PyObject_HEAD
+ DB *di_bsddb;
+ int di_size; /* -1 means recompute */
+ int di_type;
#ifdef WITH_THREAD
- PyThread_type_lock di_lock;
+ PyThread_type_lock di_lock;
#endif
} bsddbobject;
@@ -44,819 +44,819 @@
#define is_bsddbobject(v) ((v)->ob_type == &Bsddbtype)
#define check_bsddbobject_open(v, r) if ((v)->di_bsddb == NULL) \
{ PyErr_SetString(BsddbError, \
- "BSDDB object has already been closed"); \
+ "BSDDB object has already been closed"); \
return r; }
static PyObject *BsddbError;
static PyObject *
newdbhashobject(char *file, int flags, int mode,
- int bsize, int ffactor, int nelem, int cachesize,
- int hash, int lorder)
+ int bsize, int ffactor, int nelem, int cachesize,
+ int hash, int lorder)
{
- bsddbobject *dp;
- HASHINFO info;
+ bsddbobject *dp;
+ HASHINFO info;
- if ((dp = PyObject_New(bsddbobject, &Bsddbtype)) == NULL)
- return NULL;
+ if ((dp = PyObject_New(bsddbobject, &Bsddbtype)) == NULL)
+ return NULL;
- info.bsize = bsize;
- info.ffactor = ffactor;
- info.nelem = nelem;
- info.cachesize = cachesize;
- info.hash = NULL; /* XXX should derive from hash argument */
- info.lorder = lorder;
+ info.bsize = bsize;
+ info.ffactor = ffactor;
+ info.nelem = nelem;
+ info.cachesize = cachesize;
+ info.hash = NULL; /* XXX should derive from hash argument */
+ info.lorder = lorder;
#ifdef O_BINARY
- flags |= O_BINARY;
+ flags |= O_BINARY;
#endif
- Py_BEGIN_ALLOW_THREADS
- dp->di_bsddb = dbopen(file, flags, mode, DB_HASH, &info);
- Py_END_ALLOW_THREADS
- if (dp->di_bsddb == NULL) {
- PyErr_SetFromErrno(BsddbError);
+ Py_BEGIN_ALLOW_THREADS
+ dp->di_bsddb = dbopen(file, flags, mode, DB_HASH, &info);
+ Py_END_ALLOW_THREADS
+ if (dp->di_bsddb == NULL) {
+ PyErr_SetFromErrno(BsddbError);
#ifdef WITH_THREAD
- dp->di_lock = NULL;
+ dp->di_lock = NULL;
#endif
- Py_DECREF(dp);
- return NULL;
- }
+ Py_DECREF(dp);
+ return NULL;
+ }
- dp->di_size = -1;
- dp->di_type = DB_HASH;
+ dp->di_size = -1;
+ dp->di_type = DB_HASH;
#ifdef WITH_THREAD
- dp->di_lock = PyThread_allocate_lock();
- if (dp->di_lock == NULL) {
- PyErr_SetString(BsddbError, "can't allocate lock");
- Py_DECREF(dp);
- return NULL;
- }
+ dp->di_lock = PyThread_allocate_lock();
+ if (dp->di_lock == NULL) {
+ PyErr_SetString(BsddbError, "can't allocate lock");
+ Py_DECREF(dp);
+ return NULL;
+ }
#endif
- return (PyObject *)dp;
+ return (PyObject *)dp;
}
static PyObject *
newdbbtobject(char *file, int flags, int mode,
- int btflags, int cachesize, int maxkeypage,
- int minkeypage, int psize, int lorder)
+ int btflags, int cachesize, int maxkeypage,
+ int minkeypage, int psize, int lorder)
{
- bsddbobject *dp;
- BTREEINFO info;
+ bsddbobject *dp;
+ BTREEINFO info;
- if ((dp = PyObject_New(bsddbobject, &Bsddbtype)) == NULL)
- return NULL;
+ if ((dp = PyObject_New(bsddbobject, &Bsddbtype)) == NULL)
+ return NULL;
- info.flags = btflags;
- info.cachesize = cachesize;
- info.maxkeypage = maxkeypage;
- info.minkeypage = minkeypage;
- info.psize = psize;
- info.lorder = lorder;
- info.compare = 0; /* Use default comparison functions, for now..*/
- info.prefix = 0;
+ info.flags = btflags;
+ info.cachesize = cachesize;
+ info.maxkeypage = maxkeypage;
+ info.minkeypage = minkeypage;
+ info.psize = psize;
+ info.lorder = lorder;
+ info.compare = 0; /* Use default comparison functions, for now..*/
+ info.prefix = 0;
#ifdef O_BINARY
- flags |= O_BINARY;
+ flags |= O_BINARY;
#endif
- Py_BEGIN_ALLOW_THREADS
- dp->di_bsddb = dbopen(file, flags, mode, DB_BTREE, &info);
- Py_END_ALLOW_THREADS
- if (dp->di_bsddb == NULL) {
- PyErr_SetFromErrno(BsddbError);
+ Py_BEGIN_ALLOW_THREADS
+ dp->di_bsddb = dbopen(file, flags, mode, DB_BTREE, &info);
+ Py_END_ALLOW_THREADS
+ if (dp->di_bsddb == NULL) {
+ PyErr_SetFromErrno(BsddbError);
#ifdef WITH_THREAD
- dp->di_lock = NULL;
+ dp->di_lock = NULL;
#endif
- Py_DECREF(dp);
- return NULL;
- }
+ Py_DECREF(dp);
+ return NULL;
+ }
- dp->di_size = -1;
- dp->di_type = DB_BTREE;
+ dp->di_size = -1;
+ dp->di_type = DB_BTREE;
#ifdef WITH_THREAD
- dp->di_lock = PyThread_allocate_lock();
- if (dp->di_lock == NULL) {
- PyErr_SetString(BsddbError, "can't allocate lock");
- Py_DECREF(dp);
- return NULL;
- }
+ dp->di_lock = PyThread_allocate_lock();
+ if (dp->di_lock == NULL) {
+ PyErr_SetString(BsddbError, "can't allocate lock");
+ Py_DECREF(dp);
+ return NULL;
+ }
#endif
- return (PyObject *)dp;
+ return (PyObject *)dp;
}
static PyObject *
newdbrnobject(char *file, int flags, int mode,
- int rnflags, int cachesize, int psize, int lorder,
- size_t reclen, u_char bval, char *bfname)
+ int rnflags, int cachesize, int psize, int lorder,
+ size_t reclen, u_char bval, char *bfname)
{
- bsddbobject *dp;
- RECNOINFO info;
- int fd;
+ bsddbobject *dp;
+ RECNOINFO info;
+ int fd;
- if ((dp = PyObject_New(bsddbobject, &Bsddbtype)) == NULL)
- return NULL;
+ if ((dp = PyObject_New(bsddbobject, &Bsddbtype)) == NULL)
+ return NULL;
- info.flags = rnflags;
- info.cachesize = cachesize;
- info.psize = psize;
- info.lorder = lorder;
- info.reclen = reclen;
- info.bval = bval;
- info.bfname = bfname;
+ info.flags = rnflags;
+ info.cachesize = cachesize;
+ info.psize = psize;
+ info.lorder = lorder;
+ info.reclen = reclen;
+ info.bval = bval;
+ info.bfname = bfname;
#ifdef O_BINARY
- flags |= O_BINARY;
+ flags |= O_BINARY;
#endif
- /* This is a hack to avoid a dbopen() bug that happens when
- * it fails. */
- fd = open(file, flags);
- if (fd == -1) {
- dp->di_bsddb = NULL;
- }
- else {
- close(fd);
- Py_BEGIN_ALLOW_THREADS
- dp->di_bsddb = dbopen(file, flags, mode, DB_RECNO, &info);
- Py_END_ALLOW_THREADS
- }
- if (dp->di_bsddb == NULL) {
- PyErr_SetFromErrno(BsddbError);
+ /* This is a hack to avoid a dbopen() bug that happens when
+ * it fails. */
+ fd = open(file, flags);
+ if (fd == -1) {
+ dp->di_bsddb = NULL;
+ }
+ else {
+ close(fd);
+ Py_BEGIN_ALLOW_THREADS
+ dp->di_bsddb = dbopen(file, flags, mode, DB_RECNO, &info);
+ Py_END_ALLOW_THREADS
+ }
+ if (dp->di_bsddb == NULL) {
+ PyErr_SetFromErrno(BsddbError);
#ifdef WITH_THREAD
- dp->di_lock = NULL;
+ dp->di_lock = NULL;
#endif
- Py_DECREF(dp);
- return NULL;
- }
+ Py_DECREF(dp);
+ return NULL;
+ }
- dp->di_size = -1;
- dp->di_type = DB_RECNO;
+ dp->di_size = -1;
+ dp->di_type = DB_RECNO;
#ifdef WITH_THREAD
- dp->di_lock = PyThread_allocate_lock();
- if (dp->di_lock == NULL) {
- PyErr_SetString(BsddbError, "can't allocate lock");
- Py_DECREF(dp);
- return NULL;
- }
+ dp->di_lock = PyThread_allocate_lock();
+ if (dp->di_lock == NULL) {
+ PyErr_SetString(BsddbError, "can't allocate lock");
+ Py_DECREF(dp);
+ return NULL;
+ }
#endif
- return (PyObject *)dp;
+ return (PyObject *)dp;
}
static void
bsddb_dealloc(bsddbobject *dp)
{
#ifdef WITH_THREAD
- if (dp->di_lock) {
- PyThread_acquire_lock(dp->di_lock, 0);
- PyThread_release_lock(dp->di_lock);
- PyThread_free_lock(dp->di_lock);
- dp->di_lock = NULL;
- }
+ if (dp->di_lock) {
+ PyThread_acquire_lock(dp->di_lock, 0);
+ PyThread_release_lock(dp->di_lock);
+ PyThread_free_lock(dp->di_lock);
+ dp->di_lock = NULL;
+ }
#endif
- if (dp->di_bsddb != NULL) {
- int status;
- Py_BEGIN_ALLOW_THREADS
- status = (dp->di_bsddb->close)(dp->di_bsddb);
- Py_END_ALLOW_THREADS
- if (status != 0)
- fprintf(stderr,
- "Python bsddb: close errno %d in dealloc\n",
- errno);
- }
- PyObject_Del(dp);
+ if (dp->di_bsddb != NULL) {
+ int status;
+ Py_BEGIN_ALLOW_THREADS
+ status = (dp->di_bsddb->close)(dp->di_bsddb);
+ Py_END_ALLOW_THREADS
+ if (status != 0)
+ fprintf(stderr,
+ "Python bsddb: close errno %d in dealloc\n",
+ errno);
+ }
+ PyObject_Del(dp);
}
#ifdef WITH_THREAD
#define BSDDB_BGN_SAVE(_dp) \
- Py_BEGIN_ALLOW_THREADS PyThread_acquire_lock(_dp->di_lock,1);
+ Py_BEGIN_ALLOW_THREADS PyThread_acquire_lock(_dp->di_lock,1);
#define BSDDB_END_SAVE(_dp) \
- PyThread_release_lock(_dp->di_lock); Py_END_ALLOW_THREADS
+ PyThread_release_lock(_dp->di_lock); Py_END_ALLOW_THREADS
#else
-#define BSDDB_BGN_SAVE(_dp) Py_BEGIN_ALLOW_THREADS
+#define BSDDB_BGN_SAVE(_dp) Py_BEGIN_ALLOW_THREADS
#define BSDDB_END_SAVE(_dp) Py_END_ALLOW_THREADS
#endif
static Py_ssize_t
bsddb_length(bsddbobject *dp)
{
- check_bsddbobject_open(dp, -1);
- if (dp->di_size < 0) {
- DBT krec, drec;
- int status;
- int size = 0;
- BSDDB_BGN_SAVE(dp)
- for (status = (dp->di_bsddb->seq)(dp->di_bsddb,
- &krec, &drec,R_FIRST);
- status == 0;
- status = (dp->di_bsddb->seq)(dp->di_bsddb,
- &krec, &drec, R_NEXT))
- size++;
- BSDDB_END_SAVE(dp)
- if (status < 0) {
- PyErr_SetFromErrno(BsddbError);
- return -1;
- }
- dp->di_size = size;
- }
- return dp->di_size;
+ check_bsddbobject_open(dp, -1);
+ if (dp->di_size < 0) {
+ DBT krec, drec;
+ int status;
+ int size = 0;
+ BSDDB_BGN_SAVE(dp)
+ for (status = (dp->di_bsddb->seq)(dp->di_bsddb,
+ &krec, &drec,R_FIRST);
+ status == 0;
+ status = (dp->di_bsddb->seq)(dp->di_bsddb,
+ &krec, &drec, R_NEXT))
+ size++;
+ BSDDB_END_SAVE(dp)
+ if (status < 0) {
+ PyErr_SetFromErrno(BsddbError);
+ return -1;
+ }
+ dp->di_size = size;
+ }
+ return dp->di_size;
}
static PyObject *
bsddb_subscript(bsddbobject *dp, PyObject *key)
{
- int status;
- DBT krec, drec;
- char *data,buf[4096];
- int size;
- PyObject *result;
- recno_t recno;
-
- if (dp->di_type == DB_RECNO) {
- if (!PyArg_Parse(key, "i", &recno)) {
- PyErr_SetString(PyExc_TypeError,
- "key type must be integer");
- return NULL;
- }
- krec.data = &recno;
- krec.size = sizeof(recno);
- }
- else {
- if (!PyArg_Parse(key, "s#", &data, &size)) {
- PyErr_SetString(PyExc_TypeError,
- "key type must be string");
- return NULL;
- }
- krec.data = data;
- krec.size = size;
- }
- check_bsddbobject_open(dp, NULL);
+ int status;
+ DBT krec, drec;
+ char *data,buf[4096];
+ int size;
+ PyObject *result;
+ recno_t recno;
- BSDDB_BGN_SAVE(dp)
- status = (dp->di_bsddb->get)(dp->di_bsddb, &krec, &drec, 0);
- if (status == 0) {
- if (drec.size > sizeof(buf)) data = malloc(drec.size);
- else data = buf;
- if (data!=NULL) memcpy(data,drec.data,drec.size);
- }
- BSDDB_END_SAVE(dp)
- if (data==NULL) return PyErr_NoMemory();
- if (status != 0) {
- if (status < 0)
- PyErr_SetFromErrno(BsddbError);
- else
- PyErr_SetObject(PyExc_KeyError, key);
- return NULL;
- }
+ if (dp->di_type == DB_RECNO) {
+ if (!PyArg_Parse(key, "i", &recno)) {
+ PyErr_SetString(PyExc_TypeError,
+ "key type must be integer");
+ return NULL;
+ }
+ krec.data = &recno;
+ krec.size = sizeof(recno);
+ }
+ else {
+ if (!PyArg_Parse(key, "s#", &data, &size)) {
+ PyErr_SetString(PyExc_TypeError,
+ "key type must be string");
+ return NULL;
+ }
+ krec.data = data;
+ krec.size = size;
+ }
+ check_bsddbobject_open(dp, NULL);
- result = PyString_FromStringAndSize(data, (int)drec.size);
- if (data != buf) free(data);
- return result;
+ BSDDB_BGN_SAVE(dp)
+ status = (dp->di_bsddb->get)(dp->di_bsddb, &krec, &drec, 0);
+ if (status == 0) {
+ if (drec.size > sizeof(buf)) data = malloc(drec.size);
+ else data = buf;
+ if (data!=NULL) memcpy(data,drec.data,drec.size);
+ }
+ BSDDB_END_SAVE(dp)
+ if (data==NULL) return PyErr_NoMemory();
+ if (status != 0) {
+ if (status < 0)
+ PyErr_SetFromErrno(BsddbError);
+ else
+ PyErr_SetObject(PyExc_KeyError, key);
+ return NULL;
+ }
+
+ result = PyString_FromStringAndSize(data, (int)drec.size);
+ if (data != buf) free(data);
+ return result;
}
static int
bsddb_ass_sub(bsddbobject *dp, PyObject *key, PyObject *value)
{
- int status;
- DBT krec, drec;
- char *data;
- int size;
- recno_t recno;
+ int status;
+ DBT krec, drec;
+ char *data;
+ int size;
+ recno_t recno;
- if (dp->di_type == DB_RECNO) {
- if (!PyArg_Parse(key, "i", &recno)) {
- PyErr_SetString(PyExc_TypeError,
- "bsddb key type must be integer");
- return -1;
- }
- krec.data = &recno;
- krec.size = sizeof(recno);
- }
- else {
- if (!PyArg_Parse(key, "s#", &data, &size)) {
- PyErr_SetString(PyExc_TypeError,
- "bsddb key type must be string");
- return -1;
- }
- krec.data = data;
- krec.size = size;
- }
- check_bsddbobject_open(dp, -1);
- dp->di_size = -1;
- if (value == NULL) {
- BSDDB_BGN_SAVE(dp)
- status = (dp->di_bsddb->del)(dp->di_bsddb, &krec, 0);
- BSDDB_END_SAVE(dp)
- }
- else {
- if (!PyArg_Parse(value, "s#", &data, &size)) {
- PyErr_SetString(PyExc_TypeError,
- "bsddb value type must be string");
- return -1;
- }
- drec.data = data;
- drec.size = size;
- BSDDB_BGN_SAVE(dp)
- status = (dp->di_bsddb->put)(dp->di_bsddb, &krec, &drec, 0);
- BSDDB_END_SAVE(dp)
- }
- if (status != 0) {
- if (status < 0)
- PyErr_SetFromErrno(BsddbError);
- else
- PyErr_SetObject(PyExc_KeyError, key);
- return -1;
- }
- return 0;
+ if (dp->di_type == DB_RECNO) {
+ if (!PyArg_Parse(key, "i", &recno)) {
+ PyErr_SetString(PyExc_TypeError,
+ "bsddb key type must be integer");
+ return -1;
+ }
+ krec.data = &recno;
+ krec.size = sizeof(recno);
+ }
+ else {
+ if (!PyArg_Parse(key, "s#", &data, &size)) {
+ PyErr_SetString(PyExc_TypeError,
+ "bsddb key type must be string");
+ return -1;
+ }
+ krec.data = data;
+ krec.size = size;
+ }
+ check_bsddbobject_open(dp, -1);
+ dp->di_size = -1;
+ if (value == NULL) {
+ BSDDB_BGN_SAVE(dp)
+ status = (dp->di_bsddb->del)(dp->di_bsddb, &krec, 0);
+ BSDDB_END_SAVE(dp)
+ }
+ else {
+ if (!PyArg_Parse(value, "s#", &data, &size)) {
+ PyErr_SetString(PyExc_TypeError,
+ "bsddb value type must be string");
+ return -1;
+ }
+ drec.data = data;
+ drec.size = size;
+ BSDDB_BGN_SAVE(dp)
+ status = (dp->di_bsddb->put)(dp->di_bsddb, &krec, &drec, 0);
+ BSDDB_END_SAVE(dp)
+ }
+ if (status != 0) {
+ if (status < 0)
+ PyErr_SetFromErrno(BsddbError);
+ else
+ PyErr_SetObject(PyExc_KeyError, key);
+ return -1;
+ }
+ return 0;
}
static PyMappingMethods bsddb_as_mapping = {
- (lenfunc)bsddb_length, /*mp_length*/
- (binaryfunc)bsddb_subscript, /*mp_subscript*/
- (objobjargproc)bsddb_ass_sub, /*mp_ass_subscript*/
+ (lenfunc)bsddb_length, /*mp_length*/
+ (binaryfunc)bsddb_subscript, /*mp_subscript*/
+ (objobjargproc)bsddb_ass_sub, /*mp_ass_subscript*/
};
static PyObject *
bsddb_close(bsddbobject *dp)
{
- if (dp->di_bsddb != NULL) {
- int status;
- BSDDB_BGN_SAVE(dp)
- status = (dp->di_bsddb->close)(dp->di_bsddb);
- BSDDB_END_SAVE(dp)
- if (status != 0) {
- dp->di_bsddb = NULL;
- PyErr_SetFromErrno(BsddbError);
- return NULL;
- }
- }
- dp->di_bsddb = NULL;
- Py_INCREF(Py_None);
- return Py_None;
+ if (dp->di_bsddb != NULL) {
+ int status;
+ BSDDB_BGN_SAVE(dp)
+ status = (dp->di_bsddb->close)(dp->di_bsddb);
+ BSDDB_END_SAVE(dp)
+ if (status != 0) {
+ dp->di_bsddb = NULL;
+ PyErr_SetFromErrno(BsddbError);
+ return NULL;
+ }
+ }
+ dp->di_bsddb = NULL;
+ Py_INCREF(Py_None);
+ return Py_None;
}
static PyObject *
bsddb_keys(bsddbobject *dp)
{
- PyObject *list, *item=NULL;
- DBT krec, drec;
- char *data=NULL,buf[4096];
- int status;
- int err;
+ PyObject *list, *item=NULL;
+ DBT krec, drec;
+ char *data=NULL,buf[4096];
+ int status;
+ int err;
- check_bsddbobject_open(dp, NULL);
- list = PyList_New(0);
- if (list == NULL)
- return NULL;
- BSDDB_BGN_SAVE(dp)
- status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_FIRST);
- if (status == 0) {
- if (krec.size > sizeof(buf)) data = malloc(krec.size);
- else data = buf;
- if (data != NULL) memcpy(data,krec.data,krec.size);
- }
- BSDDB_END_SAVE(dp)
- if (status == 0 && data==NULL) return PyErr_NoMemory();
- while (status == 0) {
- if (dp->di_type == DB_RECNO)
- item = PyInt_FromLong(*((int*)data));
- else
- item = PyString_FromStringAndSize(data,
- (int)krec.size);
- if (data != buf) free(data);
- if (item == NULL) {
- Py_DECREF(list);
- return NULL;
- }
- err = PyList_Append(list, item);
- Py_DECREF(item);
- if (err != 0) {
- Py_DECREF(list);
- return NULL;
- }
- BSDDB_BGN_SAVE(dp)
- status = (dp->di_bsddb->seq)
- (dp->di_bsddb, &krec, &drec, R_NEXT);
- if (status == 0) {
- if (krec.size > sizeof(buf))
- data = malloc(krec.size);
- else data = buf;
- if (data != NULL)
- memcpy(data,krec.data,krec.size);
- }
- BSDDB_END_SAVE(dp)
- if (data == NULL) return PyErr_NoMemory();
- }
- if (status < 0) {
- PyErr_SetFromErrno(BsddbError);
- Py_DECREF(list);
- return NULL;
- }
- if (dp->di_size < 0)
- dp->di_size = PyList_Size(list); /* We just did the work */
- return list;
+ check_bsddbobject_open(dp, NULL);
+ list = PyList_New(0);
+ if (list == NULL)
+ return NULL;
+ BSDDB_BGN_SAVE(dp)
+ status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_FIRST);
+ if (status == 0) {
+ if (krec.size > sizeof(buf)) data = malloc(krec.size);
+ else data = buf;
+ if (data != NULL) memcpy(data,krec.data,krec.size);
+ }
+ BSDDB_END_SAVE(dp)
+ if (status == 0 && data==NULL) return PyErr_NoMemory();
+ while (status == 0) {
+ if (dp->di_type == DB_RECNO)
+ item = PyInt_FromLong(*((int*)data));
+ else
+ item = PyString_FromStringAndSize(data,
+ (int)krec.size);
+ if (data != buf) free(data);
+ if (item == NULL) {
+ Py_DECREF(list);
+ return NULL;
+ }
+ err = PyList_Append(list, item);
+ Py_DECREF(item);
+ if (err != 0) {
+ Py_DECREF(list);
+ return NULL;
+ }
+ BSDDB_BGN_SAVE(dp)
+ status = (dp->di_bsddb->seq)
+ (dp->di_bsddb, &krec, &drec, R_NEXT);
+ if (status == 0) {
+ if (krec.size > sizeof(buf))
+ data = malloc(krec.size);
+ else data = buf;
+ if (data != NULL)
+ memcpy(data,krec.data,krec.size);
+ }
+ BSDDB_END_SAVE(dp)
+ if (data == NULL) return PyErr_NoMemory();
+ }
+ if (status < 0) {
+ PyErr_SetFromErrno(BsddbError);
+ Py_DECREF(list);
+ return NULL;
+ }
+ if (dp->di_size < 0)
+ dp->di_size = PyList_Size(list); /* We just did the work */
+ return list;
}
static PyObject *
bsddb_has_key(bsddbobject *dp, PyObject *args)
{
- DBT krec, drec;
- int status;
- char *data;
- int size;
- recno_t recno;
+ DBT krec, drec;
+ int status;
+ char *data;
+ int size;
+ recno_t recno;
- if (dp->di_type == DB_RECNO) {
- if (!PyArg_ParseTuple(args, "i;key type must be integer",
- &recno)) {
- return NULL;
- }
- krec.data = &recno;
- krec.size = sizeof(recno);
- }
- else {
- if (!PyArg_ParseTuple(args, "s#;key type must be string",
- &data, &size)) {
- return NULL;
- }
- krec.data = data;
- krec.size = size;
- }
- check_bsddbobject_open(dp, NULL);
+ if (dp->di_type == DB_RECNO) {
+ if (!PyArg_ParseTuple(args, "i;key type must be integer",
+ &recno)) {
+ return NULL;
+ }
+ krec.data = &recno;
+ krec.size = sizeof(recno);
+ }
+ else {
+ if (!PyArg_ParseTuple(args, "s#;key type must be string",
+ &data, &size)) {
+ return NULL;
+ }
+ krec.data = data;
+ krec.size = size;
+ }
+ check_bsddbobject_open(dp, NULL);
- BSDDB_BGN_SAVE(dp)
- status = (dp->di_bsddb->get)(dp->di_bsddb, &krec, &drec, 0);
- BSDDB_END_SAVE(dp)
- if (status < 0) {
- PyErr_SetFromErrno(BsddbError);
- return NULL;
- }
+ BSDDB_BGN_SAVE(dp)
+ status = (dp->di_bsddb->get)(dp->di_bsddb, &krec, &drec, 0);
+ BSDDB_END_SAVE(dp)
+ if (status < 0) {
+ PyErr_SetFromErrno(BsddbError);
+ return NULL;
+ }
- return PyInt_FromLong(status == 0);
+ return PyInt_FromLong(status == 0);
}
static PyObject *
bsddb_set_location(bsddbobject *dp, PyObject *key)
{
- int status;
- DBT krec, drec;
- char *data,buf[4096];
- int size;
- PyObject *result;
- recno_t recno;
+ int status;
+ DBT krec, drec;
+ char *data,buf[4096];
+ int size;
+ PyObject *result;
+ recno_t recno;
- if (dp->di_type == DB_RECNO) {
- if (!PyArg_ParseTuple(key, "i;key type must be integer",
- &recno)) {
- return NULL;
- }
- krec.data = &recno;
- krec.size = sizeof(recno);
- }
- else {
- if (!PyArg_ParseTuple(key, "s#;key type must be string",
- &data, &size)) {
- return NULL;
- }
- krec.data = data;
- krec.size = size;
- }
- check_bsddbobject_open(dp, NULL);
+ if (dp->di_type == DB_RECNO) {
+ if (!PyArg_ParseTuple(key, "i;key type must be integer",
+ &recno)) {
+ return NULL;
+ }
+ krec.data = &recno;
+ krec.size = sizeof(recno);
+ }
+ else {
+ if (!PyArg_ParseTuple(key, "s#;key type must be string",
+ &data, &size)) {
+ return NULL;
+ }
+ krec.data = data;
+ krec.size = size;
+ }
+ check_bsddbobject_open(dp, NULL);
- BSDDB_BGN_SAVE(dp)
- status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_CURSOR);
- if (status == 0) {
- if (drec.size > sizeof(buf)) data = malloc(drec.size);
- else data = buf;
- if (data!=NULL) memcpy(data,drec.data,drec.size);
- }
- BSDDB_END_SAVE(dp)
- if (data==NULL) return PyErr_NoMemory();
- if (status != 0) {
- if (status < 0)
- PyErr_SetFromErrno(BsddbError);
- else
- PyErr_SetObject(PyExc_KeyError, key);
- return NULL;
- }
+ BSDDB_BGN_SAVE(dp)
+ status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_CURSOR);
+ if (status == 0) {
+ if (drec.size > sizeof(buf)) data = malloc(drec.size);
+ else data = buf;
+ if (data!=NULL) memcpy(data,drec.data,drec.size);
+ }
+ BSDDB_END_SAVE(dp)
+ if (data==NULL) return PyErr_NoMemory();
+ if (status != 0) {
+ if (status < 0)
+ PyErr_SetFromErrno(BsddbError);
+ else
+ PyErr_SetObject(PyExc_KeyError, key);
+ return NULL;
+ }
- if (dp->di_type == DB_RECNO)
- result = Py_BuildValue("is#", *((int*)krec.data),
- data, drec.size);
- else
- result = Py_BuildValue("s#s#", krec.data, krec.size,
- data, drec.size);
- if (data != buf) free(data);
- return result;
+ if (dp->di_type == DB_RECNO)
+ result = Py_BuildValue("is#", *((int*)krec.data),
+ data, drec.size);
+ else
+ result = Py_BuildValue("s#s#", krec.data, krec.size,
+ data, drec.size);
+ if (data != buf) free(data);
+ return result;
}
static PyObject *
bsddb_seq(bsddbobject *dp, int sequence_request)
{
- int status;
- DBT krec, drec;
- char *kdata=NULL,kbuf[4096];
- char *ddata=NULL,dbuf[4096];
- PyObject *result;
+ int status;
+ DBT krec, drec;
+ char *kdata=NULL,kbuf[4096];
+ char *ddata=NULL,dbuf[4096];
+ PyObject *result;
- check_bsddbobject_open(dp, NULL);
- krec.data = 0;
- krec.size = 0;
+ check_bsddbobject_open(dp, NULL);
+ krec.data = 0;
+ krec.size = 0;
- BSDDB_BGN_SAVE(dp)
- status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec,
- &drec, sequence_request);
- if (status == 0) {
- if (krec.size > sizeof(kbuf)) kdata = malloc(krec.size);
- else kdata = kbuf;
- if (kdata != NULL) memcpy(kdata,krec.data,krec.size);
- if (drec.size > sizeof(dbuf)) ddata = malloc(drec.size);
- else ddata = dbuf;
- if (ddata != NULL) memcpy(ddata,drec.data,drec.size);
- }
- BSDDB_END_SAVE(dp)
- if (status == 0) {
- if ((kdata == NULL) || (ddata == NULL))
- return PyErr_NoMemory();
- }
- else {
- /* (status != 0) */
- if (status < 0)
- PyErr_SetFromErrno(BsddbError);
- else
- PyErr_SetString(PyExc_KeyError, "no key/data pairs");
- return NULL;
- }
+ BSDDB_BGN_SAVE(dp)
+ status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec,
+ &drec, sequence_request);
+ if (status == 0) {
+ if (krec.size > sizeof(kbuf)) kdata = malloc(krec.size);
+ else kdata = kbuf;
+ if (kdata != NULL) memcpy(kdata,krec.data,krec.size);
+ if (drec.size > sizeof(dbuf)) ddata = malloc(drec.size);
+ else ddata = dbuf;
+ if (ddata != NULL) memcpy(ddata,drec.data,drec.size);
+ }
+ BSDDB_END_SAVE(dp)
+ if (status == 0) {
+ if ((kdata == NULL) || (ddata == NULL))
+ return PyErr_NoMemory();
+ }
+ else {
+ /* (status != 0) */
+ if (status < 0)
+ PyErr_SetFromErrno(BsddbError);
+ else
+ PyErr_SetString(PyExc_KeyError, "no key/data pairs");
+ return NULL;
+ }
- if (dp->di_type == DB_RECNO)
- result = Py_BuildValue("is#", *((int*)kdata),
- ddata, drec.size);
- else
- result = Py_BuildValue("s#s#", kdata, krec.size,
- ddata, drec.size);
- if (kdata != kbuf) free(kdata);
- if (ddata != dbuf) free(ddata);
- return result;
+ if (dp->di_type == DB_RECNO)
+ result = Py_BuildValue("is#", *((int*)kdata),
+ ddata, drec.size);
+ else
+ result = Py_BuildValue("s#s#", kdata, krec.size,
+ ddata, drec.size);
+ if (kdata != kbuf) free(kdata);
+ if (ddata != dbuf) free(ddata);
+ return result;
}
static PyObject *
bsddb_next(bsddbobject *dp)
{
- return bsddb_seq(dp, R_NEXT);
+ return bsddb_seq(dp, R_NEXT);
}
static PyObject *
bsddb_previous(bsddbobject *dp)
{
- return bsddb_seq(dp, R_PREV);
+ return bsddb_seq(dp, R_PREV);
}
static PyObject *
bsddb_first(bsddbobject *dp)
{
- return bsddb_seq(dp, R_FIRST);
+ return bsddb_seq(dp, R_FIRST);
}
static PyObject *
bsddb_last(bsddbobject *dp)
{
- return bsddb_seq(dp, R_LAST);
+ return bsddb_seq(dp, R_LAST);
}
static PyObject *
bsddb_sync(bsddbobject *dp)
{
- int status;
+ int status;
- check_bsddbobject_open(dp, NULL);
- BSDDB_BGN_SAVE(dp)
- status = (dp->di_bsddb->sync)(dp->di_bsddb, 0);
- BSDDB_END_SAVE(dp)
- if (status != 0) {
- PyErr_SetFromErrno(BsddbError);
- return NULL;
- }
- return PyInt_FromLong(status = 0);
+ check_bsddbobject_open(dp, NULL);
+ BSDDB_BGN_SAVE(dp)
+ status = (dp->di_bsddb->sync)(dp->di_bsddb, 0);
+ BSDDB_END_SAVE(dp)
+ if (status != 0) {
+ PyErr_SetFromErrno(BsddbError);
+ return NULL;
+ }
+ return PyInt_FromLong(status = 0);
}
static PyMethodDef bsddb_methods[] = {
- {"close", (PyCFunction)bsddb_close, METH_NOARGS},
- {"keys", (PyCFunction)bsddb_keys, METH_NOARGS},
- {"has_key", (PyCFunction)bsddb_has_key, METH_VARARGS},
- {"set_location", (PyCFunction)bsddb_set_location, METH_VARARGS},
- {"next", (PyCFunction)bsddb_next, METH_NOARGS},
- {"previous", (PyCFunction)bsddb_previous, METH_NOARGS},
- {"first", (PyCFunction)bsddb_first, METH_NOARGS},
- {"last", (PyCFunction)bsddb_last, METH_NOARGS},
- {"sync", (PyCFunction)bsddb_sync, METH_NOARGS},
- {NULL, NULL} /* sentinel */
+ {"close", (PyCFunction)bsddb_close, METH_NOARGS},
+ {"keys", (PyCFunction)bsddb_keys, METH_NOARGS},
+ {"has_key", (PyCFunction)bsddb_has_key, METH_VARARGS},
+ {"set_location", (PyCFunction)bsddb_set_location, METH_VARARGS},
+ {"next", (PyCFunction)bsddb_next, METH_NOARGS},
+ {"previous", (PyCFunction)bsddb_previous, METH_NOARGS},
+ {"first", (PyCFunction)bsddb_first, METH_NOARGS},
+ {"last", (PyCFunction)bsddb_last, METH_NOARGS},
+ {"sync", (PyCFunction)bsddb_sync, METH_NOARGS},
+ {NULL, NULL} /* sentinel */
};
static PyObject *
bsddb_getattr(PyObject *dp, char *name)
{
- return Py_FindMethod(bsddb_methods, dp, name);
+ return Py_FindMethod(bsddb_methods, dp, name);
}
static PyTypeObject Bsddbtype = {
- PyObject_HEAD_INIT(NULL)
- 0,
- "bsddb.bsddb",
- sizeof(bsddbobject),
- 0,
- (destructor)bsddb_dealloc, /*tp_dealloc*/
- 0, /*tp_print*/
- (getattrfunc)bsddb_getattr, /*tp_getattr*/
- 0, /*tp_setattr*/
- 0, /*tp_compare*/
- 0, /*tp_repr*/
- 0, /*tp_as_number*/
- 0, /*tp_as_sequence*/
- &bsddb_as_mapping, /*tp_as_mapping*/
+ PyObject_HEAD_INIT(NULL)
+ 0,
+ "bsddb.bsddb",
+ sizeof(bsddbobject),
+ 0,
+ (destructor)bsddb_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc)bsddb_getattr, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ 0, /*tp_compare*/
+ 0, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ &bsddb_as_mapping, /*tp_as_mapping*/
};
static PyObject *
bsdhashopen(PyObject *self, PyObject *args)
{
- char *file;
- char *flag = NULL;
- int flags = O_RDONLY;
- int mode = 0666;
- int bsize = 0;
- int ffactor = 0;
- int nelem = 0;
- int cachesize = 0;
- int hash = 0; /* XXX currently ignored */
- int lorder = 0;
+ char *file;
+ char *flag = NULL;
+ int flags = O_RDONLY;
+ int mode = 0666;
+ int bsize = 0;
+ int ffactor = 0;
+ int nelem = 0;
+ int cachesize = 0;
+ int hash = 0; /* XXX currently ignored */
+ int lorder = 0;
- if (!PyArg_ParseTuple(args, "z|siiiiiii:hashopen",
- &file, &flag, &mode,
- &bsize, &ffactor, &nelem, &cachesize,
- &hash, &lorder))
- return NULL;
- if (flag != NULL) {
- /* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
- if (flag[0] == 'r')
- flags = O_RDONLY;
- else if (flag[0] == 'w')
- flags = O_RDWR;
- else if (flag[0] == 'c')
- flags = O_RDWR|O_CREAT;
- else if (flag[0] == 'n')
- flags = O_RDWR|O_CREAT|O_TRUNC;
- else {
- PyErr_SetString(BsddbError,
- "Flag should begin with 'r', 'w', 'c' or 'n'");
- return NULL;
- }
- if (flag[1] == 'l') {
+ if (!PyArg_ParseTuple(args, "z|siiiiiii:hashopen",
+ &file, &flag, &mode,
+ &bsize, &ffactor, &nelem, &cachesize,
+ &hash, &lorder))
+ return NULL;
+ if (flag != NULL) {
+ /* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
+ if (flag[0] == 'r')
+ flags = O_RDONLY;
+ else if (flag[0] == 'w')
+ flags = O_RDWR;
+ else if (flag[0] == 'c')
+ flags = O_RDWR|O_CREAT;
+ else if (flag[0] == 'n')
+ flags = O_RDWR|O_CREAT|O_TRUNC;
+ else {
+ PyErr_SetString(BsddbError,
+ "Flag should begin with 'r', 'w', 'c' or 'n'");
+ return NULL;
+ }
+ if (flag[1] == 'l') {
#if defined(O_EXLOCK) && defined(O_SHLOCK)
- if (flag[0] == 'r')
- flags |= O_SHLOCK;
- else
- flags |= O_EXLOCK;
+ if (flag[0] == 'r')
+ flags |= O_SHLOCK;
+ else
+ flags |= O_EXLOCK;
#else
- PyErr_SetString(BsddbError,
- "locking not supported on this platform");
- return NULL;
+ PyErr_SetString(BsddbError,
+ "locking not supported on this platform");
+ return NULL;
#endif
- }
- }
- return newdbhashobject(file, flags, mode,
- bsize, ffactor, nelem, cachesize, hash, lorder);
+ }
+ }
+ return newdbhashobject(file, flags, mode,
+ bsize, ffactor, nelem, cachesize, hash, lorder);
}
static PyObject *
bsdbtopen(PyObject *self, PyObject *args)
{
- char *file;
- char *flag = NULL;
- int flags = O_RDONLY;
- int mode = 0666;
- int cachesize = 0;
- int maxkeypage = 0;
- int minkeypage = 0;
- int btflags = 0;
- unsigned int psize = 0;
- int lorder = 0;
+ char *file;
+ char *flag = NULL;
+ int flags = O_RDONLY;
+ int mode = 0666;
+ int cachesize = 0;
+ int maxkeypage = 0;
+ int minkeypage = 0;
+ int btflags = 0;
+ unsigned int psize = 0;
+ int lorder = 0;
- if (!PyArg_ParseTuple(args, "z|siiiiiii:btopen",
- &file, &flag, &mode,
- &btflags, &cachesize, &maxkeypage, &minkeypage,
- &psize, &lorder))
- return NULL;
- if (flag != NULL) {
- /* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
- if (flag[0] == 'r')
- flags = O_RDONLY;
- else if (flag[0] == 'w')
- flags = O_RDWR;
- else if (flag[0] == 'c')
- flags = O_RDWR|O_CREAT;
- else if (flag[0] == 'n')
- flags = O_RDWR|O_CREAT|O_TRUNC;
- else {
- PyErr_SetString(BsddbError,
- "Flag should begin with 'r', 'w', 'c' or 'n'");
- return NULL;
- }
- if (flag[1] == 'l') {
+ if (!PyArg_ParseTuple(args, "z|siiiiiii:btopen",
+ &file, &flag, &mode,
+ &btflags, &cachesize, &maxkeypage, &minkeypage,
+ &psize, &lorder))
+ return NULL;
+ if (flag != NULL) {
+ /* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
+ if (flag[0] == 'r')
+ flags = O_RDONLY;
+ else if (flag[0] == 'w')
+ flags = O_RDWR;
+ else if (flag[0] == 'c')
+ flags = O_RDWR|O_CREAT;
+ else if (flag[0] == 'n')
+ flags = O_RDWR|O_CREAT|O_TRUNC;
+ else {
+ PyErr_SetString(BsddbError,
+ "Flag should begin with 'r', 'w', 'c' or 'n'");
+ return NULL;
+ }
+ if (flag[1] == 'l') {
#if defined(O_EXLOCK) && defined(O_SHLOCK)
- if (flag[0] == 'r')
- flags |= O_SHLOCK;
- else
- flags |= O_EXLOCK;
+ if (flag[0] == 'r')
+ flags |= O_SHLOCK;
+ else
+ flags |= O_EXLOCK;
#else
- PyErr_SetString(BsddbError,
- "locking not supported on this platform");
- return NULL;
+ PyErr_SetString(BsddbError,
+ "locking not supported on this platform");
+ return NULL;
#endif
- }
- }
- return newdbbtobject(file, flags, mode,
- btflags, cachesize, maxkeypage, minkeypage,
- psize, lorder);
+ }
+ }
+ return newdbbtobject(file, flags, mode,
+ btflags, cachesize, maxkeypage, minkeypage,
+ psize, lorder);
}
static PyObject *
bsdrnopen(PyObject *self, PyObject *args)
{
- char *file;
- char *flag = NULL;
- int flags = O_RDONLY;
- int mode = 0666;
- int cachesize = 0;
- int rnflags = 0;
- unsigned int psize = 0;
- int lorder = 0;
- size_t reclen = 0;
- char *bval = "";
- char *bfname = NULL;
+ char *file;
+ char *flag = NULL;
+ int flags = O_RDONLY;
+ int mode = 0666;
+ int cachesize = 0;
+ int rnflags = 0;
+ unsigned int psize = 0;
+ int lorder = 0;
+ size_t reclen = 0;
+ char *bval = "";
+ char *bfname = NULL;
- if (!PyArg_ParseTuple(args, "z|siiiiiiss:rnopen",
- &file, &flag, &mode,
- &rnflags, &cachesize, &psize, &lorder,
- &reclen, &bval, &bfname))
- return NULL;
+ if (!PyArg_ParseTuple(args, "z|siiiiiiss:rnopen",
+ &file, &flag, &mode,
+ &rnflags, &cachesize, &psize, &lorder,
+ &reclen, &bval, &bfname))
+ return NULL;
- if (flag != NULL) {
- /* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
- if (flag[0] == 'r')
- flags = O_RDONLY;
- else if (flag[0] == 'w')
- flags = O_RDWR;
- else if (flag[0] == 'c')
- flags = O_RDWR|O_CREAT;
- else if (flag[0] == 'n')
- flags = O_RDWR|O_CREAT|O_TRUNC;
- else {
- PyErr_SetString(BsddbError,
- "Flag should begin with 'r', 'w', 'c' or 'n'");
- return NULL;
- }
- if (flag[1] == 'l') {
+ if (flag != NULL) {
+ /* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
+ if (flag[0] == 'r')
+ flags = O_RDONLY;
+ else if (flag[0] == 'w')
+ flags = O_RDWR;
+ else if (flag[0] == 'c')
+ flags = O_RDWR|O_CREAT;
+ else if (flag[0] == 'n')
+ flags = O_RDWR|O_CREAT|O_TRUNC;
+ else {
+ PyErr_SetString(BsddbError,
+ "Flag should begin with 'r', 'w', 'c' or 'n'");
+ return NULL;
+ }
+ if (flag[1] == 'l') {
#if defined(O_EXLOCK) && defined(O_SHLOCK)
- if (flag[0] == 'r')
- flags |= O_SHLOCK;
- else
- flags |= O_EXLOCK;
+ if (flag[0] == 'r')
+ flags |= O_SHLOCK;
+ else
+ flags |= O_EXLOCK;
#else
- PyErr_SetString(BsddbError,
- "locking not supported on this platform");
- return NULL;
+ PyErr_SetString(BsddbError,
+ "locking not supported on this platform");
+ return NULL;
#endif
- }
- else if (flag[1] != '\0') {
- PyErr_SetString(BsddbError,
- "Flag char 2 should be 'l' or absent");
- return NULL;
- }
- }
- return newdbrnobject(file, flags, mode, rnflags, cachesize,
- psize, lorder, reclen, bval[0], bfname);
+ }
+ else if (flag[1] != '\0') {
+ PyErr_SetString(BsddbError,
+ "Flag char 2 should be 'l' or absent");
+ return NULL;
+ }
+ }
+ return newdbrnobject(file, flags, mode, rnflags, cachesize,
+ psize, lorder, reclen, bval[0], bfname);
}
static PyMethodDef bsddbmodule_methods[] = {
- {"hashopen", (PyCFunction)bsdhashopen, METH_VARARGS},
- {"btopen", (PyCFunction)bsdbtopen, METH_VARARGS},
- {"rnopen", (PyCFunction)bsdrnopen, METH_VARARGS},
- /* strictly for use by dbhhash!!! */
- {"open", (PyCFunction)bsdhashopen, METH_VARARGS},
- {0, 0},
+ {"hashopen", (PyCFunction)bsdhashopen, METH_VARARGS},
+ {"btopen", (PyCFunction)bsdbtopen, METH_VARARGS},
+ {"rnopen", (PyCFunction)bsdrnopen, METH_VARARGS},
+ /* strictly for use by dbhhash!!! */
+ {"open", (PyCFunction)bsdhashopen, METH_VARARGS},
+ {0, 0},
};
PyMODINIT_FUNC
initbsddb185(void) {
- PyObject *m, *d;
+ PyObject *m, *d;
if (PyErr_WarnPy3k("the bsddb185 module has been removed in "
"Python 3.0", 2) < 0)
- return;
+ return;
- Bsddbtype.ob_type = &PyType_Type;
- m = Py_InitModule("bsddb185", bsddbmodule_methods);
- if (m == NULL)
- return;
- d = PyModule_GetDict(m);
- BsddbError = PyErr_NewException("bsddb.error", NULL, NULL);
- if (BsddbError != NULL)
- PyDict_SetItemString(d, "error", BsddbError);
+ Bsddbtype.ob_type = &PyType_Type;
+ m = Py_InitModule("bsddb185", bsddbmodule_methods);
+ if (m == NULL)
+ return;
+ d = PyModule_GetDict(m);
+ BsddbError = PyErr_NewException("bsddb.error", NULL, NULL);
+ if (BsddbError != NULL)
+ PyDict_SetItemString(d, "error", BsddbError);
}