Skip to content

C
cpython
Kaydet (Commit) d9240d19 authored tarafından Roger E. Masse's avatar Roger E. Masse
Dosyalara gözat
Seçenekler

Already renamed. Indented.

üst eca63b83
Hide whitespace changes
Inline Side-by-side
Showing with 513 additions and 471 deletions
Modules/bsddbmodule.c
Dosyayı görüntüle @ d9240d19
...@@ -50,9 +50,9 @@ PERFORMANCE OF THIS SOFTWARE. ...@@ -50,9 +50,9 @@ PERFORMANCE OF THIS SOFTWARE.
(it messes up the info required in the Setup file) */ (it messes up the info required in the Setup file) */
typedef struct { typedef struct {
PyObject_HEAD PyObject_HEAD
DB *di_bsddb; DB *di_bsddb;
int di_size; /* -1 means recompute */ int di_size; /* -1 means recompute */
} bsddbobject; } bsddbobject;
staticforward PyTypeObject Bsddbtype; staticforward PyTypeObject Bsddbtype;
...@@ -64,627 +64,669 @@ static PyObject *BsddbError; ...@@ -64,627 +64,669 @@ static PyObject *BsddbError;
static PyObject * static PyObject *
newdbhashobject(file, flags, mode, newdbhashobject(file, flags, mode,
bsize, ffactor, nelem, cachesize, hash, lorder) bsize, ffactor, nelem, cachesize, hash, lorder)
char *file; char *file;
int flags; int flags;
int mode; int mode;
int bsize; int bsize;
int ffactor; int ffactor;
int nelem; int nelem;
int cachesize; int cachesize;
int hash; /* XXX ignored */ int hash; /* XXX ignored */
int lorder; int lorder;
{ {
bsddbobject *dp; bsddbobject *dp;
HASHINFO info; HASHINFO info;
if ((dp = PyObject_NEW(bsddbobject, &Bsddbtype)) == NULL) if ((dp = PyObject_NEW(bsddbobject, &Bsddbtype)) == NULL)
return NULL; return NULL;
info.bsize = bsize; info.bsize = bsize;
info.ffactor = ffactor; info.ffactor = ffactor;
info.nelem = nelem; info.nelem = nelem;
info.cachesize = cachesize; info.cachesize = cachesize;
info.hash = NULL; /* XXX should derive from hash argument */ info.hash = NULL; /* XXX should derive from hash argument */
info.lorder = lorder; info.lorder = lorder;
#ifdef O_BINARY #ifdef O_BINARY
flags |= O_BINARY; flags |= O_BINARY;
#endif #endif
if ((dp->di_bsddb = dbopen(file, flags, mode, DB_HASH, &info)) == NULL) { if ((dp->di_bsddb = dbopen(file, flags,
PyErr_SetFromErrno(BsddbError); mode, DB_HASH, &info)) == NULL) {
Py_DECREF(dp); PyErr_SetFromErrno(BsddbError);
return NULL; Py_DECREF(dp);
} return NULL;
}
dp->di_size = -1; dp->di_size = -1;
return (PyObject *)dp; return (PyObject *)dp;
} }
static PyObject * static PyObject *
newdbbtobject(file, flags, mode, newdbbtobject(file, flags, mode,
btflags, cachesize, maxkeypage, minkeypage, psize, lorder) btflags, cachesize, maxkeypage, minkeypage, psize, lorder)
char *file; char *file;
int flags; int flags;
int mode; int mode;
int btflags; int btflags;
int cachesize; int cachesize;
int maxkeypage; int maxkeypage;
int minkeypage; int minkeypage;
int psize; int psize;
int lorder; int lorder;
{ {
bsddbobject *dp; bsddbobject *dp;
BTREEINFO info; BTREEINFO info;
if ((dp = PyObject_NEW(bsddbobject, &Bsddbtype)) == NULL) if ((dp = PyObject_NEW(bsddbobject, &Bsddbtype)) == NULL)
return NULL; return NULL;
info.flags = btflags; info.flags = btflags;
info.cachesize = cachesize; info.cachesize = cachesize;
info.maxkeypage = maxkeypage; info.maxkeypage = maxkeypage;
info.minkeypage = minkeypage; info.minkeypage = minkeypage;
info.psize = psize; info.psize = psize;
info.lorder = lorder; info.lorder = lorder;
info.compare = 0; /* Use default comparison functions, for now..*/ info.compare = 0; /* Use default comparison functions, for now..*/
info.prefix = 0; info.prefix = 0;
#ifdef O_BINARY #ifdef O_BINARY
flags |= O_BINARY; flags |= O_BINARY;
#endif #endif
if ((dp->di_bsddb = dbopen(file, flags, mode, DB_BTREE, &info)) == NULL) { if ((dp->di_bsddb = dbopen(file, flags,
PyErr_SetFromErrno(BsddbError); mode, DB_BTREE, &info)) == NULL) {
Py_DECREF(dp); PyErr_SetFromErrno(BsddbError);
return NULL; Py_DECREF(dp);
} return NULL;
}
dp->di_size = -1; dp->di_size = -1;
return (PyObject *)dp; return (PyObject *)dp;
} }
static PyObject * static PyObject *
newdbrnobject(file, flags, mode, newdbrnobject(file, flags, mode,
rnflags, cachesize, psize, lorder, reclen, bval, bfname) rnflags, cachesize, psize, lorder, reclen, bval, bfname)
char *file; char *file;
int flags; int flags;
int mode; int mode;
int rnflags; int rnflags;
int cachesize; int cachesize;
int psize; int psize;
int lorder; int lorder;
size_t reclen; size_t reclen;
u_char bval; u_char bval;
char *bfname; char *bfname;
{ {
bsddbobject *dp; bsddbobject *dp;
RECNOINFO info; RECNOINFO info;
if ((dp = PyObject_NEW(bsddbobject, &Bsddbtype)) == NULL) if ((dp = PyObject_NEW(bsddbobject, &Bsddbtype)) == NULL)
return NULL; return NULL;
info.flags = rnflags; info.flags = rnflags;
info.cachesize = cachesize; info.cachesize = cachesize;
info.psize = psize; info.psize = psize;
info.lorder = lorder; info.lorder = lorder;
info.reclen = reclen; info.reclen = reclen;
info.bval = bval; info.bval = bval;
info.bfname = bfname; info.bfname = bfname;
#ifdef O_BINARY #ifdef O_BINARY
flags |= O_BINARY; flags |= O_BINARY;
#endif #endif
if ((dp->di_bsddb = dbopen(file, flags, mode, DB_RECNO, &info)) == NULL) { if ((dp->di_bsddb = dbopen(file, flags, mode,
PyErr_SetFromErrno(BsddbError); DB_RECNO, &info)) == NULL) {
Py_DECREF(dp); PyErr_SetFromErrno(BsddbError);
return NULL; Py_DECREF(dp);
} return NULL;
}
dp->di_size = -1; dp->di_size = -1;
return (PyObject *)dp; return (PyObject *)dp;
} }
static void static void
bsddb_dealloc(dp) bsddb_dealloc(dp)
bsddbobject *dp; bsddbobject *dp;
{ {
if (dp->di_bsddb != NULL) { if (dp->di_bsddb != NULL) {
if ((dp->di_bsddb->close)(dp->di_bsddb) != 0) if ((dp->di_bsddb->close)(dp->di_bsddb) != 0)
fprintf(stderr, fprintf(stderr,
"Python bsddb: close errno %d in dealloc\n", errno); "Python bsddb: close errno %d in dealloc\n",
} errno);
PyMem_DEL(dp); }
PyMem_DEL(dp);
} }
static int static int
bsddb_length(dp) bsddb_length(dp)
bsddbobject *dp; bsddbobject *dp;
{ {
if (dp->di_size < 0) { if (dp->di_size < 0) {
DBT krec, drec; DBT krec, drec;
int status; int status;
int size = 0; int size = 0;
for (status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec,R_FIRST); for (status = (dp->di_bsddb->seq)(dp->di_bsddb,
status == 0; &krec, &drec,R_FIRST);
status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_NEXT)) status == 0;
size++; status = (dp->di_bsddb->seq)(dp->di_bsddb,
if (status < 0) { &krec, &drec, R_NEXT))
PyErr_SetFromErrno(BsddbError); size++;
return -1; if (status < 0) {
PyErr_SetFromErrno(BsddbError);
return -1;
}
dp->di_size = size;
} }
dp->di_size = size; return dp->di_size;
}
return dp->di_size;
} }
static PyObject * static PyObject *
bsddb_subscript(dp, key) bsddb_subscript(dp, key)
bsddbobject *dp; bsddbobject *dp;
PyObject *key; PyObject *key;
{ {
int status; int status;
DBT krec, drec; DBT krec, drec;
char *data; char *data;
int size; int size;
if (!PyArg_Parse(key, "s#", &data, &size)) if (!PyArg_Parse(key, "s#", &data, &size))
return NULL; return NULL;
krec.data = data; krec.data = data;
krec.size = size; krec.size = size;
status = (dp->di_bsddb->get)(dp->di_bsddb, &krec, &drec, 0); status = (dp->di_bsddb->get)(dp->di_bsddb, &krec, &drec, 0);
if (status != 0) { if (status != 0) {
if (status < 0) if (status < 0)
PyErr_SetFromErrno(BsddbError); PyErr_SetFromErrno(BsddbError);
else else
PyErr_SetObject(PyExc_KeyError, key); PyErr_SetObject(PyExc_KeyError, key);
return NULL; return NULL;
} }
return PyString_FromStringAndSize((char *)drec.data, (int)drec.size); return PyString_FromStringAndSize((char *)drec.data, (int)drec.size);
} }
static int static int
bsddb_ass_sub(dp, key, value) bsddb_ass_sub(dp, key, value)
bsddbobject *dp; bsddbobject *dp;
PyObject *key, *value; PyObject *key, *value;
{ {
int status; int status;
DBT krec, drec; DBT krec, drec;
char *data; char *data;
int size; int size;
if (!PyArg_Parse(key, "s#", &data, &size)) { if (!PyArg_Parse(key, "s#", &data, &size)) {
PyErr_SetString(PyExc_TypeError, "bsddb key type must be string"); PyErr_SetString(PyExc_TypeError,
return -1; "bsddb key type must be string");
} return -1;
krec.data = data; }
krec.size = size; krec.data = data;
dp->di_size = -1; krec.size = size;
if (value == NULL) { dp->di_size = -1;
status = (dp->di_bsddb->del)(dp->di_bsddb, &krec, 0); if (value == NULL) {
} status = (dp->di_bsddb->del)(dp->di_bsddb, &krec, 0);
else { }
if (!PyArg_Parse(value, "s#", &data, &size)) { else {
PyErr_SetString(PyExc_TypeError, "bsddb value type must be string"); if (!PyArg_Parse(value, "s#", &data, &size)) {
return -1; PyErr_SetString(PyExc_TypeError,
"bsddb value type must be string");
return -1;
}
drec.data = data;
drec.size = size;
#if 0
/* For RECNO, put fails with 'No space left on device'
after a few short records are added?? Looks fine
to this point... linked with 1.85 on Solaris Intel
Roger E. Masse 1/16/97
*/
printf("before put data: '%s', size: %d\n",
drec.data, drec.size);
printf("before put key= '%s', size= %d\n",
krec.data, krec.size);
#endif
status = (dp->di_bsddb->put)(dp->di_bsddb, &krec, &drec, 0);
} }
drec.data = data; if (status != 0) {
drec.size = size; if (status < 0)
status = (dp->di_bsddb->put)(dp->di_bsddb, &krec, &drec, 0); PyErr_SetFromErrno(BsddbError);
} else
if (status != 0) { PyErr_SetObject(PyExc_KeyError, key);
if (status < 0) return -1;
PyErr_SetFromErrno(BsddbError); }
else return 0;
PyErr_SetObject(PyExc_KeyError, key);
return -1;
}
return 0;
} }
static PyMappingMethods bsddb_as_mapping = { static PyMappingMethods bsddb_as_mapping = {
(inquiry)bsddb_length, /*mp_length*/ (inquiry)bsddb_length, /*mp_length*/
(binaryfunc)bsddb_subscript, /*mp_subscript*/ (binaryfunc)bsddb_subscript, /*mp_subscript*/
(objobjargproc)bsddb_ass_sub, /*mp_ass_subscript*/ (objobjargproc)bsddb_ass_sub, /*mp_ass_subscript*/
}; };
static PyObject * static PyObject *
bsddb_close(dp, args) bsddb_close(dp, args)
bsddbobject *dp; bsddbobject *dp;
PyObject *args; PyObject *args;
{ {
if (!PyArg_NoArgs(args)) if (!PyArg_NoArgs(args))
return NULL; return NULL;
if (dp->di_bsddb != NULL) { if (dp->di_bsddb != NULL) {
if ((dp->di_bsddb->close)(dp->di_bsddb) != 0) { if ((dp->di_bsddb->close)(dp->di_bsddb) != 0) {
dp->di_bsddb = NULL; dp->di_bsddb = NULL;
PyErr_SetFromErrno(BsddbError); PyErr_SetFromErrno(BsddbError);
return NULL; return NULL;
}
} }
} dp->di_bsddb = NULL;
dp->di_bsddb = NULL; Py_INCREF(Py_None);
Py_INCREF(Py_None); return Py_None;
return Py_None;
} }
static PyObject * static PyObject *
bsddb_keys(dp, args) bsddb_keys(dp, args)
bsddbobject *dp; bsddbobject *dp;
PyObject *args; PyObject *args;
{ {
PyObject *list, *item; PyObject *list, *item;
DBT krec, drec; DBT krec, drec;
int status; int status;
int err; int err;
if (!PyArg_NoArgs(args)) if (!PyArg_NoArgs(args))
return NULL; return NULL;
list = PyList_New(0); list = PyList_New(0);
if (list == NULL) if (list == NULL)
return NULL; return NULL;
for (status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_FIRST); for (status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_FIRST);
status == 0; status == 0;
status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_NEXT)) { status = (dp->di_bsddb->seq)(dp->di_bsddb,
item = PyString_FromStringAndSize((char *)krec.data, (int)krec.size); &krec, &drec, R_NEXT)) {
if (item == NULL) { item = PyString_FromStringAndSize((char *)krec.data,
Py_DECREF(list); (int)krec.size);
return NULL; if (item == NULL) {
Py_DECREF(list);
return NULL;
}
err = PyList_Append(list, item);
Py_DECREF(item);
if (err != 0) {
Py_DECREF(list);
return NULL;
}
} }
err = PyList_Append(list, item); if (status < 0) {
Py_DECREF(item); PyErr_SetFromErrno(BsddbError);
if (err != 0) { Py_DECREF(list);
Py_DECREF(list); return NULL;
return NULL;
} }
} if (dp->di_size < 0)
if (status < 0) { dp->di_size = PyList_Size(list); /* We just did the work */
PyErr_SetFromErrno(BsddbError); return list;
Py_DECREF(list);
return NULL;
}
if (dp->di_size < 0)
dp->di_size = PyList_Size(list); /* We just did the work for this... */
return list;
} }
static PyObject * static PyObject *
bsddb_has_key(dp, args) bsddb_has_key(dp, args)
bsddbobject *dp; bsddbobject *dp;
PyObject *args; PyObject *args;
{ {
DBT krec, drec; DBT krec, drec;
int status; int status;
char *data; char *data;
int size; int size;
if (!PyArg_Parse(args, "s#", &data, &size)) if (!PyArg_Parse(args, "s#", &data, &size))
return NULL; return NULL;
krec.data = data; krec.data = data;
krec.size = size; krec.size = size;
status = (dp->di_bsddb->get)(dp->di_bsddb, &krec, &drec, 0); status = (dp->di_bsddb->get)(dp->di_bsddb, &krec, &drec, 0);
if (status < 0) { if (status < 0) {
PyErr_SetFromErrno(BsddbError); PyErr_SetFromErrno(BsddbError);
return NULL; return NULL;
} }
return PyInt_FromLong(status == 0); return PyInt_FromLong(status == 0);
} }
static PyObject * static PyObject *
bsddb_set_location(dp, key) bsddb_set_location(dp, key)
bsddbobject *dp; bsddbobject *dp;
PyObject *key; PyObject *key;
{ {
int status; int status;
DBT krec, drec; DBT krec, drec;
char *data; char *data;
int size; int size;
if (!PyArg_Parse(key, "s#", &data, &size)) if (!PyArg_Parse(key, "s#", &data, &size))
return NULL; return NULL;
krec.data = data; krec.data = data;
krec.size = size; krec.size = size;
status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_CURSOR); status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_CURSOR);
if (status != 0) { if (status != 0) {
if (status < 0) if (status < 0)
PyErr_SetFromErrno(BsddbError); PyErr_SetFromErrno(BsddbError);
else else
PyErr_SetObject(PyExc_KeyError, key); PyErr_SetObject(PyExc_KeyError, key);
return NULL; return NULL;
} }
return Py_BuildValue("s#s#", krec.data, krec.size, drec.data, drec.size); return Py_BuildValue("s#s#", krec.data, krec.size,
drec.data, drec.size);
} }
static PyObject * static PyObject *
bsddb_seq(dp, args, sequence_request) bsddb_seq(dp, args, sequence_request)
bsddbobject *dp; bsddbobject *dp;
PyObject *args; PyObject *args;
int sequence_request; int sequence_request;
{ {
int status; int status;
DBT krec, drec; DBT krec, drec;
if (!PyArg_NoArgs(args)) if (!PyArg_NoArgs(args))
return NULL; return NULL;
krec.data = 0; krec.data = 0;
krec.size = 0; krec.size = 0;
status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, sequence_request); status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec,
if (status != 0) { &drec, sequence_request);
if (status < 0) if (status != 0) {
PyErr_SetFromErrno(BsddbError); if (status < 0)
else PyErr_SetFromErrno(BsddbError);
PyErr_SetObject(PyExc_KeyError, args); else
return NULL; PyErr_SetObject(PyExc_KeyError, args);
} return NULL;
}
return Py_BuildValue("s#s#", krec.data, krec.size, drec.data, drec.size); return Py_BuildValue("s#s#", krec.data, krec.size,
drec.data, drec.size);
} }
static PyObject * static PyObject *
bsddb_next(dp, key) bsddb_next(dp, key)
bsddbobject *dp; bsddbobject *dp;
PyObject *key; PyObject *key;
{ {
return bsddb_seq(dp, key, R_NEXT); return bsddb_seq(dp, key, R_NEXT);
} }
static PyObject * static PyObject *
bsddb_previous(dp, key) bsddb_previous(dp, key)
bsddbobject *dp; bsddbobject *dp;
PyObject *key; PyObject *key;
{ {
return bsddb_seq(dp, key, R_PREV); return bsddb_seq(dp, key, R_PREV);
} }
static PyObject * static PyObject *
bsddb_first(dp, key) bsddb_first(dp, key)
bsddbobject *dp; bsddbobject *dp;
PyObject *key; PyObject *key;
{ {
return bsddb_seq(dp, key, R_FIRST); return bsddb_seq(dp, key, R_FIRST);
} }
static PyObject * static PyObject *
bsddb_last(dp, key) bsddb_last(dp, key)
bsddbobject *dp; bsddbobject *dp;
PyObject *key; PyObject *key;
{ {
return bsddb_seq(dp, key, R_LAST); return bsddb_seq(dp, key, R_LAST);
} }
static PyObject * static PyObject *
bsddb_sync(dp, args) bsddb_sync(dp, args)
bsddbobject *dp; bsddbobject *dp;
PyObject *args; PyObject *args;
{ {
int status; int status;
status = (dp->di_bsddb->sync)(dp->di_bsddb, 0); status = (dp->di_bsddb->sync)(dp->di_bsddb, 0);
if (status != 0) { if (status != 0) {
PyErr_SetFromErrno(BsddbError); PyErr_SetFromErrno(BsddbError);
return NULL; return NULL;
} }
return PyInt_FromLong(status = 0); return PyInt_FromLong(status = 0);
} }
static PyMethodDef bsddb_methods[] = { static PyMethodDef bsddb_methods[] = {
{"close", (PyCFunction)bsddb_close}, {"close", (PyCFunction)bsddb_close},
{"keys", (PyCFunction)bsddb_keys}, {"keys", (PyCFunction)bsddb_keys},
{"has_key", (PyCFunction)bsddb_has_key}, {"has_key", (PyCFunction)bsddb_has_key},
{"set_location", (PyCFunction)bsddb_set_location}, {"set_location", (PyCFunction)bsddb_set_location},
{"next", (PyCFunction)bsddb_next}, {"next", (PyCFunction)bsddb_next},
{"previous", (PyCFunction)bsddb_previous}, {"previous", (PyCFunction)bsddb_previous},
{"first", (PyCFunction)bsddb_first}, {"first", (PyCFunction)bsddb_first},
{"last", (PyCFunction)bsddb_last}, {"last", (PyCFunction)bsddb_last},
{"sync", (PyCFunction)bsddb_sync}, {"sync", (PyCFunction)bsddb_sync},
{NULL, NULL} /* sentinel */ {NULL, NULL} /* sentinel */
}; };
static PyObject * static PyObject *
bsddb_getattr(dp, name) bsddb_getattr(dp, name)
PyObject *dp; PyObject *dp;
char *name; char *name;
{ {
return Py_FindMethod(bsddb_methods, dp, name); return Py_FindMethod(bsddb_methods, dp, name);
} }
static PyTypeObject Bsddbtype = { static PyTypeObject Bsddbtype = {
PyObject_HEAD_INIT(NULL) PyObject_HEAD_INIT(NULL)
0, 0,
"bsddb", "bsddb",
sizeof(bsddbobject), sizeof(bsddbobject),
0, 0,
(destructor)bsddb_dealloc, /*tp_dealloc*/ (destructor)bsddb_dealloc, /*tp_dealloc*/
0, /*tp_print*/ 0, /*tp_print*/
(getattrfunc)bsddb_getattr, /*tp_getattr*/ (getattrfunc)bsddb_getattr, /*tp_getattr*/
0, /*tp_setattr*/ 0, /*tp_setattr*/
0, /*tp_compare*/ 0, /*tp_compare*/
0, /*tp_repr*/ 0, /*tp_repr*/
0, /*tp_as_number*/ 0, /*tp_as_number*/
0, /*tp_as_sequence*/ 0, /*tp_as_sequence*/
&bsddb_as_mapping, /*tp_as_mapping*/ &bsddb_as_mapping, /*tp_as_mapping*/
}; };
static PyObject * static PyObject *
bsdhashopen(self, args) bsdhashopen(self, args)
PyObject *self; PyObject *self;
PyObject *args; PyObject *args;
{ {
char *file; char *file;
char *flag = NULL; char *flag = NULL;
int flags = O_RDONLY; int flags = O_RDONLY;
int mode = 0666; int mode = 0666;
int bsize = 0; int bsize = 0;
int ffactor = 0; int ffactor = 0;
int nelem = 0; int nelem = 0;
int cachesize = 0; int cachesize = 0;
int hash = 0; /* XXX currently ignored */ int hash = 0; /* XXX currently ignored */
int lorder = 0; int lorder = 0;
if (!PyArg_ParseTuple(args, "s|siiiiiii", if (!PyArg_ParseTuple(args, "s|siiiiiii",
&file, &flag, &mode, &file, &flag, &mode,
&bsize, &ffactor, &nelem, &cachesize, &hash, &lorder)) &bsize, &ffactor, &nelem, &cachesize,
return NULL; &hash, &lorder))
if (flag != NULL) { return NULL;
/* XXX need a way to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */ if (flag != NULL) {
if (flag[0] == 'r') /* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
flags = O_RDONLY; if (flag[0] == 'r')
else if (flag[0] == 'w') flags = O_RDONLY;
flags = O_RDWR; else if (flag[0] == 'w')
else if (flag[0] == 'c') flags = O_RDWR;
flags = O_RDWR|O_CREAT; else if (flag[0] == 'c')
else if (flag[0] == 'n') flags = O_RDWR|O_CREAT;
flags = O_RDWR|O_CREAT|O_TRUNC; else if (flag[0] == 'n')
else { flags = O_RDWR|O_CREAT|O_TRUNC;
PyErr_SetString(BsddbError, else {
"Flag should begin with 'r', 'w', 'c' or 'n'"); PyErr_SetString(BsddbError,
return NULL; "Flag should begin with 'r', 'w', 'c' or 'n'");
} return NULL;
if (flag[1] == 'l') { }
if (flag[1] == 'l') {
#if defined(O_EXLOCK) && defined(O_SHLOCK) #if defined(O_EXLOCK) && defined(O_SHLOCK)
if (flag[0] == 'r') if (flag[0] == 'r')
flags |= O_SHLOCK; flags |= O_SHLOCK;
else else
flags |= O_EXLOCK; flags |= O_EXLOCK;
#else #else
PyErr_SetString(BsddbError, "locking not supported on this platform"); PyErr_SetString(BsddbError,
return NULL; "locking not supported on this platform");
return NULL;
#endif #endif
}
} }
} return newdbhashobject(file, flags, mode,
return newdbhashobject(file, flags, mode, bsize, ffactor, nelem, cachesize, hash, lorder);
bsize, ffactor, nelem, cachesize, hash, lorder);
} }
static PyObject * static PyObject *
bsdbtopen(self, args) bsdbtopen(self, args)
PyObject *self; PyObject *self;
PyObject *args; PyObject *args;
{ {
char *file; char *file;
char *flag = NULL; char *flag = NULL;
int flags = O_RDONLY; int flags = O_RDONLY;
int mode = 0666; int mode = 0666;
int cachesize = 0; int cachesize = 0;
int maxkeypage = 0; int maxkeypage = 0;
int minkeypage = 0; int minkeypage = 0;
int btflags = 0; int btflags = 0;
unsigned int psize = 0; unsigned int psize = 0;
int lorder = 0; int lorder = 0;
if (!PyArg_ParseTuple(args, "s|siiiiiii", if (!PyArg_ParseTuple(args, "s|siiiiiii",
&file, &flag, &mode, &file, &flag, &mode,
&btflags, &cachesize, &maxkeypage, &minkeypage, &btflags, &cachesize, &maxkeypage, &minkeypage,
&psize, &lorder)) &psize, &lorder))
return NULL; return NULL;
if (flag != NULL) { if (flag != NULL) {
/* XXX need a way to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */ /* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
if (flag[0] == 'r') if (flag[0] == 'r')
flags = O_RDONLY; flags = O_RDONLY;
else if (flag[0] == 'w') else if (flag[0] == 'w')
flags = O_RDWR; flags = O_RDWR;
else if (flag[0] == 'c') else if (flag[0] == 'c')
flags = O_RDWR|O_CREAT; flags = O_RDWR|O_CREAT;
else if (flag[0] == 'n') else if (flag[0] == 'n')
flags = O_RDWR|O_CREAT|O_TRUNC; flags = O_RDWR|O_CREAT|O_TRUNC;
else { else {
PyErr_SetString(BsddbError, PyErr_SetString(BsddbError,
"Flag should begin with 'r', 'w', 'c' or 'n'"); "Flag should begin with 'r', 'w', 'c' or 'n'");
return NULL; return NULL;
} }
if (flag[1] == 'l') { if (flag[1] == 'l') {
#if defined(O_EXLOCK) && defined(O_SHLOCK) #if defined(O_EXLOCK) && defined(O_SHLOCK)
if (flag[0] == 'r') if (flag[0] == 'r')
flags |= O_SHLOCK; flags |= O_SHLOCK;
else else
flags |= O_EXLOCK; flags |= O_EXLOCK;
#else #else
PyErr_SetString(BsddbError, "locking not supported on this platform"); PyErr_SetString(BsddbError,
return NULL; "locking not supported on this platform");
return NULL;
#endif #endif
}
} }
} return newdbbtobject(file, flags, mode,
return newdbbtobject(file, flags, mode, btflags, cachesize, maxkeypage, minkeypage,
btflags, cachesize, maxkeypage, minkeypage, psize, lorder);
psize, lorder);
} }
static PyObject * static PyObject *
bsdrnopen(self, args) bsdrnopen(self, args)
PyObject *self; PyObject *self;
PyObject *args; PyObject *args;
{ {
char *file; char *file;
char *flag = NULL; char *flag = NULL;
int flags = O_RDONLY; int flags = O_RDONLY;
int mode = 0666; int mode = 0666;
int cachesize = 0; int cachesize = 0;
int rnflags = 0; int rnflags = 0;
unsigned int psize = 0; unsigned int psize = 0;
int lorder = 0; int lorder = 0;
size_t reclen = 0; size_t reclen = 0;
char *bval = ""; char *bval = "";
char *bfname = NULL; char *bfname = NULL;
if (!PyArg_ParseTuple(args, "s|siiiiiiss", if (!PyArg_ParseTuple(args, "s|siiiiiiss",
&file, &flag, &mode, &file, &flag, &mode,
&rnflags, &cachesize, &psize, &lorder, &rnflags, &cachesize, &psize, &lorder,
&reclen, &bval, &bfname)) &reclen, &bval, &bfname))
return NULL; return NULL;
if (flag != NULL) {
/* XXX need a way to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */ # if 0
if (flag[0] == 'r') printf("file: %s\n", file);
flags = O_RDONLY; printf("flag: %s\n", flag);
else if (flag[0] == 'w') printf("mode: %d\n", mode);
flags = O_RDWR; printf("rnflags: 0x%x\n", rnflags);
else if (flag[0] == 'c') printf("cachesize: %d\n", cachesize);
flags = O_RDWR|O_CREAT; printf("psize: %d\n", psize);
else if (flag[0] == 'n') printf("lorder: %d\n", 0);
flags = O_RDWR|O_CREAT|O_TRUNC; printf("reclen: %d\n", reclen);
else { printf("bval: %c\n", bval[0]);
PyErr_SetString(BsddbError, printf("bfname %s\n", bfname);
"Flag should begin with 'r', 'w', 'c' or 'n'"); #endif
return NULL;
} if (flag != NULL) {
if (flag[1] == 'l') { /* 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 defined(O_EXLOCK) && defined(O_SHLOCK)
if (flag[0] == 'r') if (flag[0] == 'r')
flags |= O_SHLOCK; flags |= O_SHLOCK;
else else
flags |= O_EXLOCK; flags |= O_EXLOCK;
#else #else
PyErr_SetString(BsddbError, "locking not supported on this platform"); PyErr_SetString(BsddbError,
return NULL; "locking not supported on this platform");
return NULL;
#endif #endif
}
else if (flag[1] != '\0') {
PyErr_SetString(BsddbError,
"Flag char 2 should be 'l' or absent");
return NULL;
}
} }
else if (flag[1] != '\0') { return newdbrnobject(file, flags, mode, rnflags, cachesize,
PyErr_SetString(BsddbError, psize, lorder, reclen, bval[0], bfname);
"Flag char 2 should be 'l' or absent");
return NULL;
}
}
return newdbrnobject(file, flags, mode,
rnflags, cachesize, psize, lorder, bval[0], bfname);
} }
static PyMethodDef bsddbmodule_methods[] = { static PyMethodDef bsddbmodule_methods[] = {
{"hashopen", (PyCFunction)bsdhashopen, 1}, {"hashopen", (PyCFunction)bsdhashopen, 1},
{"btopen", (PyCFunction)bsdbtopen, 1}, {"btopen", (PyCFunction)bsdbtopen, 1},
{"rnopen", (PyCFunction)bsdrnopen, 1}, {"rnopen", (PyCFunction)bsdrnopen, 1},
{0, 0}, {0, 0},
}; };
void void
initbsddb() { initbsddb() {
PyObject *m, *d; PyObject *m, *d;
Bsddbtype.ob_type = &PyType_Type; Bsddbtype.ob_type = &PyType_Type;
m = Py_InitModule("bsddb", bsddbmodule_methods); m = Py_InitModule("bsddb", bsddbmodule_methods);
d = PyModule_GetDict(m); d = PyModule_GetDict(m);
BsddbError = PyString_FromString("bsddb.error"); BsddbError = PyString_FromString("bsddb.error");
if (BsddbError == NULL || PyDict_SetItemString(d, "error", BsddbError)) if (BsddbError == NULL || PyDict_SetItemString(d, "error", BsddbError))
Py_FatalError("can't define bsddb.error"); Py_FatalError("can't define bsddb.error");
} }
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment