bsddbmodule.c

/* Berkeley DB interface.
 Author: Michael McLay
 Hacked: Guido van Rossum
 Btree and Recno additions plus sequence methods: David Ely
 Hacked by Gustavo Niemeyer <niemeyer@conectiva.com> fixing recno
 support.

 XXX To do:
 - provide a way to access the various hash functions
 - support more open flags

 The windows port of the Berkeley DB code is hard to find on the web:
 www.nightmare.com/software.html
*/

#include"Python.h"
#ifdefWITH_THREAD
#include"pythread.h"
#endif

#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#ifdefHAVE_DB_185_H
#include<db_185.h>
#else
#include<db.h>
#endif
/* Please don't include internal header files of the Berkeley db package
 (it messes up the info required in the Setup file) */

typedefstruct {
PyObject_HEAD
DB*di_bsddb;
intdi_size; /* -1 means recompute */
intdi_type;
#ifdefWITH_THREAD
PyThread_type_lockdi_lock;
#endif
} bsddbobject;

staticPyTypeObjectBsddbtype;

#defineis_bsddbobject(v) ((v)->ob_type == &Bsddbtype)
#definecheck_bsddbobject_open(v, r) if ((v)->di_bsddb == NULL) \
 { PyErr_SetString(BsddbError, \
 "BSDDB object has already been closed"); \
 return r; }

staticPyObject*BsddbError;

staticPyObject*
newdbhashobject(char*file, intflags, intmode,
intbsize, intffactor, intnelem, intcachesize,
inthash, intlorder)
{
bsddbobject*dp;
HASHINFOinfo;

if ((dp=PyObject_New(bsddbobject, &Bsddbtype)) ==NULL)
returnNULL;

info.bsize=bsize;
info.ffactor=ffactor;
info.nelem=nelem;
info.cachesize=cachesize;
info.hash=NULL; /* XXX should derive from hash argument */
info.lorder=lorder;

#ifdefO_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);
#ifdefWITH_THREAD
dp->di_lock=NULL;
#endif
Py_DECREF(dp);
returnNULL;
 }

dp->di_size=-1;
dp->di_type=DB_HASH;

#ifdefWITH_THREAD
dp->di_lock=PyThread_allocate_lock();
if (dp->di_lock==NULL) {
PyErr_SetString(BsddbError, "can't allocate lock");
Py_DECREF(dp);
returnNULL;
 }
#endif

return (PyObject*)dp;
}

staticPyObject*
newdbbtobject(char*file, intflags, intmode,
intbtflags, intcachesize, intmaxkeypage,
intminkeypage, intpsize, intlorder)
{
bsddbobject*dp;
BTREEINFOinfo;

if ((dp=PyObject_New(bsddbobject, &Bsddbtype)) ==NULL)
returnNULL;

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;

#ifdefO_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);
#ifdefWITH_THREAD
dp->di_lock=NULL;
#endif
Py_DECREF(dp);
returnNULL;
 }

dp->di_size=-1;
dp->di_type=DB_BTREE;

#ifdefWITH_THREAD
dp->di_lock=PyThread_allocate_lock();
if (dp->di_lock==NULL) {
PyErr_SetString(BsddbError, "can't allocate lock");
Py_DECREF(dp);
returnNULL;
 }
#endif

return (PyObject*)dp;
}

staticPyObject*
newdbrnobject(char*file, intflags, intmode,
intrnflags, intcachesize, intpsize, intlorder,
size_treclen, u_charbval, char*bfname)
{
bsddbobject*dp;
RECNOINFOinfo;
intfd;

if ((dp=PyObject_New(bsddbobject, &Bsddbtype)) ==NULL)
returnNULL;

info.flags=rnflags;
info.cachesize=cachesize;
info.psize=psize;
info.lorder=lorder;
info.reclen=reclen;
info.bval=bval;
info.bfname=bfname;

#ifdefO_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);
#ifdefWITH_THREAD
dp->di_lock=NULL;
#endif
Py_DECREF(dp);
returnNULL;
 }

dp->di_size=-1;
dp->di_type=DB_RECNO;

#ifdefWITH_THREAD
dp->di_lock=PyThread_allocate_lock();
if (dp->di_lock==NULL) {
PyErr_SetString(BsddbError, "can't allocate lock");
Py_DECREF(dp);
returnNULL;
 }
#endif

return (PyObject*)dp;
}

staticvoid
bsddb_dealloc(bsddbobject*dp)
{
#ifdefWITH_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;
 }
#endif
if (dp->di_bsddb!=NULL) {
intstatus;
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);
}

#ifdefWITH_THREAD
#defineBSDDB_BGN_SAVE(_dp) \
 Py_BEGIN_ALLOW_THREADS PyThread_acquire_lock(_dp->di_lock,1);
#defineBSDDB_END_SAVE(_dp) \
 PyThread_release_lock(_dp->di_lock); Py_END_ALLOW_THREADS
#else
#defineBSDDB_BGN_SAVE(_dp) Py_BEGIN_ALLOW_THREADS
#defineBSDDB_END_SAVE(_dp) Py_END_ALLOW_THREADS
#endif

staticPy_ssize_t
bsddb_length(bsddbobject*dp)
{
check_bsddbobject_open(dp, -1);
if (dp->di_size<0) {
DBTkrec, drec;
intstatus;
intsize=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;
 }
returndp->di_size;
}

staticPyObject*
bsddb_subscript(bsddbobject*dp, PyObject*key)
{
intstatus;
DBTkrec, drec;
char*data=NULL;
charbuf[4096];
intsize;
PyObject*result;
recno_trecno;

if (dp->di_type==DB_RECNO) {
if (!PyArg_Parse(key, "i", &recno)) {
PyErr_SetString(PyExc_TypeError,
"key type must be integer");
returnNULL;
 }
krec.data=&recno;
krec.size=sizeof(recno);
 }
else {
if (!PyArg_Parse(key, "s#", &data, &size)) {
PyErr_SetString(PyExc_TypeError,
"key type must be string");
returnNULL;
 }
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);
if (status==0) {
if (drec.size>sizeof(buf)) data=malloc(drec.size);
elsedata=buf;
if (data!=NULL) memcpy(data,drec.data,drec.size);
 }
BSDDB_END_SAVE(dp)
if (data==NULL) returnPyErr_NoMemory();
if (status!=0) {
if (status<0)
PyErr_SetFromErrno(BsddbError);
else
PyErr_SetObject(PyExc_KeyError, key);
returnNULL;
 }

result=PyString_FromStringAndSize(data, (int)drec.size);
if (data!=buf) free(data);
returnresult;
}

staticint
bsddb_ass_sub(bsddbobject*dp, PyObject*key, PyObject*value)
{
intstatus;
DBTkrec, drec;
char*data;
intsize;
recno_trecno;

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;
 }
return0;
}

staticPyMappingMethodsbsddb_as_mapping= {
 (lenfunc)bsddb_length, /*mp_length*/
 (binaryfunc)bsddb_subscript, /*mp_subscript*/
 (objobjargproc)bsddb_ass_sub, /*mp_ass_subscript*/
};

staticPyObject*
bsddb_close(bsddbobject*dp)
{
if (dp->di_bsddb!=NULL) {
intstatus;
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);
returnNULL;
 }
 }
dp->di_bsddb=NULL;
Py_INCREF(Py_None);
returnPy_None;
}

staticPyObject*
bsddb_keys(bsddbobject*dp)
{
PyObject*list, *item=NULL;
DBTkrec, drec;
char*data=NULL,buf[4096];
intstatus;
interr;

check_bsddbobject_open(dp, NULL);
list=PyList_New(0);
if (list==NULL)
returnNULL;
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);
elsedata=buf;
if (data!=NULL) memcpy(data,krec.data,krec.size);
 }
BSDDB_END_SAVE(dp)
if (status==0&&data==NULL) returnPyErr_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);
returnNULL;
 }
err=PyList_Append(list, item);
Py_DECREF(item);
if (err!=0) {
Py_DECREF(list);
returnNULL;
 }
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);
elsedata=buf;
if (data!=NULL)
memcpy(data,krec.data,krec.size);
 }
BSDDB_END_SAVE(dp)
if (data== NULL) returnPyErr_NoMemory();
 }
if (status<0) {
PyErr_SetFromErrno(BsddbError);
Py_DECREF(list);
returnNULL;
 }
if (dp->di_size<0)
dp->di_size=PyList_Size(list); /* We just did the work */
returnlist;
}

staticPyObject*
bsddb_has_key(bsddbobject*dp, PyObject*args)
{
DBTkrec, drec;
intstatus;
char*data;
intsize;
recno_trecno;

if (dp->di_type==DB_RECNO) {
if (!PyArg_ParseTuple(args, "i;key type must be integer",
&recno)) {
returnNULL;
 }
krec.data=&recno;
krec.size=sizeof(recno);
 }
else {
if (!PyArg_ParseTuple(args, "s#;key type must be string",
&data, &size)) {
returnNULL;
 }
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);
returnNULL;
 }

returnPyInt_FromLong(status==0);
}

staticPyObject*
bsddb_set_location(bsddbobject*dp, PyObject*key)
{
intstatus;
DBTkrec, drec;
char*data=NULL;
charbuf[4096];
intsize;
PyObject*result;
recno_trecno;

if (dp->di_type==DB_RECNO) {
if (!PyArg_ParseTuple(key, "i;key type must be integer",
&recno)) {
returnNULL;
 }
krec.data=&recno;
krec.size=sizeof(recno);
 }
else {
if (!PyArg_ParseTuple(key, "s#;key type must be string",
&data, &size)) {
returnNULL;
 }
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);
elsedata=buf;
if (data!=NULL) memcpy(data,drec.data,drec.size);
 }
BSDDB_END_SAVE(dp)
if (data==NULL) returnPyErr_NoMemory();
if (status!=0) {
if (status<0)
PyErr_SetFromErrno(BsddbError);
else
PyErr_SetObject(PyExc_KeyError, key);
returnNULL;
 }

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);
returnresult;
}

staticPyObject*
bsddb_seq(bsddbobject*dp, intsequence_request)
{
intstatus;
DBTkrec, drec;
char*kdata=NULL,kbuf[4096];
char*ddata=NULL,dbuf[4096];
PyObject*result;

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);
elsekdata=kbuf;
if (kdata!=NULL) memcpy(kdata,krec.data,krec.size);
if (drec.size>sizeof(dbuf)) ddata=malloc(drec.size);
elseddata=dbuf;
if (ddata!=NULL) memcpy(ddata,drec.data,drec.size);
 }
BSDDB_END_SAVE(dp)
if (status==0) {
if ((kdata==NULL) || (ddata==NULL))
returnPyErr_NoMemory();
 }
else {
/* (status != 0) */
if (status<0)
PyErr_SetFromErrno(BsddbError);
else
PyErr_SetString(PyExc_KeyError, "no key/data pairs");
returnNULL;
 }

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);
returnresult;
}

staticPyObject*
bsddb_next(bsddbobject*dp)
{
returnbsddb_seq(dp, R_NEXT);
}
staticPyObject*
bsddb_previous(bsddbobject*dp)
{
returnbsddb_seq(dp, R_PREV);
}
staticPyObject*
bsddb_first(bsddbobject*dp)
{
returnbsddb_seq(dp, R_FIRST);
}
staticPyObject*
bsddb_last(bsddbobject*dp)
{
returnbsddb_seq(dp, R_LAST);
}
staticPyObject*
bsddb_sync(bsddbobject*dp)
{
intstatus;

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);
returnNULL;
 }
returnPyInt_FromLong(0);
}
staticPyMethodDefbsddb_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 */
};

staticPyObject*
bsddb_getattr(PyObject*dp, char*name)
{
returnPy_FindMethod(bsddb_methods, dp, name);
}

staticPyTypeObjectBsddbtype= {
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*/
};

staticPyObject*
bsdhashopen(PyObject*self, PyObject*args)
{
char*file;
char*flag=NULL;
intflags=O_RDONLY;
intmode=0666;
intbsize=0;
intffactor=0;
intnelem=0;
intcachesize=0;
inthash=0; /* XXX currently ignored */
intlorder=0;

if (!PyArg_ParseTuple(args, "z|siiiiiii:hashopen",
&file, &flag, &mode,
&bsize, &ffactor, &nelem, &cachesize,
&hash, &lorder))
returnNULL;
if (flag!=NULL) {
/* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
if (flag[0] =='r')
flags=O_RDONLY;
elseif (flag[0] =='w')
flags=O_RDWR;
elseif (flag[0] =='c')
flags=O_RDWR|O_CREAT;
elseif (flag[0] =='n')
flags=O_RDWR|O_CREAT|O_TRUNC;
else {
PyErr_SetString(BsddbError,
"Flag should begin with 'r', 'w', 'c' or 'n'");
returnNULL;
 }
if (flag[1] =='l') {
#if defined(O_EXLOCK) && defined(O_SHLOCK)
if (flag[0] =='r')
flags |= O_SHLOCK;
else
flags |= O_EXLOCK;
#else
PyErr_SetString(BsddbError,
"locking not supported on this platform");
returnNULL;
#endif
 }
 }
returnnewdbhashobject(file, flags, mode,
bsize, ffactor, nelem, cachesize, hash, lorder);
}

staticPyObject*
bsdbtopen(PyObject*self, PyObject*args)
{
char*file;
char*flag=NULL;
intflags=O_RDONLY;
intmode=0666;
intcachesize=0;
intmaxkeypage=0;
intminkeypage=0;
intbtflags=0;
unsigned intpsize=0;
intlorder=0;

if (!PyArg_ParseTuple(args, "z|siiiiiii:btopen",
&file, &flag, &mode,
&btflags, &cachesize, &maxkeypage, &minkeypage,
&psize, &lorder))
returnNULL;
if (flag!=NULL) {
/* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
if (flag[0] =='r')
flags=O_RDONLY;
elseif (flag[0] =='w')
flags=O_RDWR;
elseif (flag[0] =='c')
flags=O_RDWR|O_CREAT;
elseif (flag[0] =='n')
flags=O_RDWR|O_CREAT|O_TRUNC;
else {
PyErr_SetString(BsddbError,
"Flag should begin with 'r', 'w', 'c' or 'n'");
returnNULL;
 }
if (flag[1] =='l') {
#if defined(O_EXLOCK) && defined(O_SHLOCK)
if (flag[0] =='r')
flags |= O_SHLOCK;
else
flags |= O_EXLOCK;
#else
PyErr_SetString(BsddbError,
"locking not supported on this platform");
returnNULL;
#endif
 }
 }
returnnewdbbtobject(file, flags, mode,
btflags, cachesize, maxkeypage, minkeypage,
psize, lorder);
}

staticPyObject*
bsdrnopen(PyObject*self, PyObject*args)
{
char*file;
char*flag=NULL;
intflags=O_RDONLY;
intmode=0666;
intcachesize=0;
intrnflags=0;
unsigned intpsize=0;
intlorder=0;
size_treclen=0;
char*bval="";
char*bfname=NULL;

if (!PyArg_ParseTuple(args, "z|siiiiiiss:rnopen",
&file, &flag, &mode,
&rnflags, &cachesize, &psize, &lorder,
&reclen, &bval, &bfname))
returnNULL;

if (flag!=NULL) {
/* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
if (flag[0] =='r')
flags=O_RDONLY;
elseif (flag[0] =='w')
flags=O_RDWR;
elseif (flag[0] =='c')
flags=O_RDWR|O_CREAT;
elseif (flag[0] =='n')
flags=O_RDWR|O_CREAT|O_TRUNC;
else {
PyErr_SetString(BsddbError,
"Flag should begin with 'r', 'w', 'c' or 'n'");
returnNULL;
 }
if (flag[1] =='l') {
#if defined(O_EXLOCK) && defined(O_SHLOCK)
if (flag[0] =='r')
flags |= O_SHLOCK;
else
flags |= O_EXLOCK;
#else
PyErr_SetString(BsddbError,
"locking not supported on this platform");
returnNULL;
#endif
 }
elseif (flag[1] !='\0') {
PyErr_SetString(BsddbError,
"Flag char 2 should be 'l' or absent");
returnNULL;
 }
 }
returnnewdbrnobject(file, flags, mode, rnflags, cachesize,
psize, lorder, reclen, bval[0], bfname);
}

staticPyMethodDefbsddbmodule_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},
};

PyMODINIT_FUNC
initbsddb185(void) {
PyObject*m, *d;

if (PyErr_WarnPy3k("the bsddb185 module has been removed in "
"Python 3.0", 2) <0)
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);
}