2
/* DBM module using dictionary interface */
5
#define PY_SSIZE_T_CLEAN
12
/* Some Linux systems install gdbm/ndbm.h, but not ndbm.h. This supports
13
* whichever configure was able to locate.
15
#if defined(HAVE_NDBM_H)
17
#if defined(PYOS_OS2) && !defined(PYCC_GCC)
18
static char *which_dbm = "ndbm";
20
static char *which_dbm = "GNU gdbm"; /* EMX port of GDBM */
22
#elif defined(HAVE_GDBM_NDBM_H)
23
#include <gdbm/ndbm.h>
24
static char *which_dbm = "GNU gdbm";
25
#elif defined(HAVE_GDBM_DASH_NDBM_H)
26
#include <gdbm-ndbm.h>
27
static char *which_dbm = "GNU gdbm";
28
#elif defined(HAVE_BERKDB_H)
30
static char *which_dbm = "Berkeley DB";
32
#error "No ndbm.h available!"
37
int di_size; /* -1 means recompute */
41
static PyTypeObject Dbmtype;
43
#define is_dbmobject(v) (Py_TYPE(v) == &Dbmtype)
44
#define check_dbmobject_open(v) if ((v)->di_dbm == NULL) \
45
{ PyErr_SetString(DbmError, "DBM object has already been closed"); \
48
static PyObject *DbmError;
51
newdbmobject(char *file, int flags, int mode)
55
dp = PyObject_New(dbmobject, &Dbmtype);
59
if ( (dp->di_dbm = dbm_open(file, flags, mode)) == 0 ) {
60
PyErr_SetFromErrno(DbmError);
64
return (PyObject *)dp;
70
dbm_dealloc(register dbmobject *dp)
73
dbm_close(dp->di_dbm);
78
dbm_length(dbmobject *dp)
80
if (dp->di_dbm == NULL) {
81
PyErr_SetString(DbmError, "DBM object has already been closed");
84
if ( dp->di_size < 0 ) {
89
for ( key=dbm_firstkey(dp->di_dbm); key.dptr;
90
key = dbm_nextkey(dp->di_dbm))
98
dbm_subscript(dbmobject *dp, register PyObject *key)
103
if (!PyArg_Parse(key, "s#", &krec.dptr, &tmp_size) )
106
krec.dsize = tmp_size;
107
check_dbmobject_open(dp);
108
drec = dbm_fetch(dp->di_dbm, krec);
109
if ( drec.dptr == 0 ) {
110
PyErr_SetObject(PyExc_KeyError, key);
113
if ( dbm_error(dp->di_dbm) ) {
114
dbm_clearerr(dp->di_dbm);
115
PyErr_SetString(DbmError, "");
118
return PyBytes_FromStringAndSize(drec.dptr, drec.dsize);
122
dbm_ass_sub(dbmobject *dp, PyObject *v, PyObject *w)
127
if ( !PyArg_Parse(v, "s#", &krec.dptr, &tmp_size) ) {
128
PyErr_SetString(PyExc_TypeError,
129
"dbm mappings have bytes or string keys only");
132
krec.dsize = tmp_size;
133
if (dp->di_dbm == NULL) {
134
PyErr_SetString(DbmError, "DBM object has already been closed");
139
if ( dbm_delete(dp->di_dbm, krec) < 0 ) {
140
dbm_clearerr(dp->di_dbm);
141
PyErr_SetObject(PyExc_KeyError, v);
145
if ( !PyArg_Parse(w, "s#", &drec.dptr, &tmp_size) ) {
146
PyErr_SetString(PyExc_TypeError,
147
"dbm mappings have byte or string elements only");
150
drec.dsize = tmp_size;
151
if ( dbm_store(dp->di_dbm, krec, drec, DBM_REPLACE) < 0 ) {
152
dbm_clearerr(dp->di_dbm);
153
PyErr_SetString(DbmError,
154
"cannot add item to database");
158
if ( dbm_error(dp->di_dbm) ) {
159
dbm_clearerr(dp->di_dbm);
160
PyErr_SetString(DbmError, "");
166
static PyMappingMethods dbm_as_mapping = {
167
(lenfunc)dbm_length, /*mp_length*/
168
(binaryfunc)dbm_subscript, /*mp_subscript*/
169
(objobjargproc)dbm_ass_sub, /*mp_ass_subscript*/
173
dbm__close(register dbmobject *dp, PyObject *unused)
176
dbm_close(dp->di_dbm);
183
dbm_keys(register dbmobject *dp, PyObject *unused)
185
register PyObject *v, *item;
189
check_dbmobject_open(dp);
193
for (key = dbm_firstkey(dp->di_dbm); key.dptr;
194
key = dbm_nextkey(dp->di_dbm)) {
195
item = PyBytes_FromStringAndSize(key.dptr, key.dsize);
200
err = PyList_Append(v, item);
211
dbm_contains(PyObject *self, PyObject *arg)
213
dbmobject *dp = (dbmobject *)self;
216
if ((dp)->di_dbm == NULL) {
217
PyErr_SetString(DbmError,
218
"DBM object has already been closed");
221
if (PyUnicode_Check(arg)) {
222
arg = _PyUnicode_AsDefaultEncodedString(arg, NULL);
226
if (!PyBytes_Check(arg)) {
227
PyErr_Format(PyExc_TypeError,
228
"dbm key must be string, not %.100s",
229
arg->ob_type->tp_name);
232
key.dptr = PyBytes_AS_STRING(arg);
233
key.dsize = PyBytes_GET_SIZE(arg);
234
val = dbm_fetch(dp->di_dbm, key);
235
return val.dptr != NULL;
238
static PySequenceMethods dbm_as_sequence = {
245
0, /* sq_ass_slice */
246
dbm_contains, /* sq_contains */
247
0, /* sq_inplace_concat */
248
0, /* sq_inplace_repeat */
252
dbm_get(register dbmobject *dp, PyObject *args)
255
PyObject *defvalue = Py_None;
259
if (!PyArg_ParseTuple(args, "s#|O:get",
260
&tmp_ptr, &tmp_size, &defvalue))
263
key.dsize = tmp_size;
264
check_dbmobject_open(dp);
265
val = dbm_fetch(dp->di_dbm, key);
266
if (val.dptr != NULL)
267
return PyBytes_FromStringAndSize(val.dptr, val.dsize);
275
dbm_setdefault(register dbmobject *dp, PyObject *args)
278
PyObject *defvalue = NULL;
282
if (!PyArg_ParseTuple(args, "s#|O:setdefault",
283
&tmp_ptr, &tmp_size, &defvalue))
286
key.dsize = tmp_size;
287
check_dbmobject_open(dp);
288
val = dbm_fetch(dp->di_dbm, key);
289
if (val.dptr != NULL)
290
return PyBytes_FromStringAndSize(val.dptr, val.dsize);
291
if (defvalue == NULL) {
292
defvalue = PyBytes_FromStringAndSize(NULL, 0);
293
if (defvalue == NULL)
299
if ( !PyArg_Parse(defvalue, "s#", &val.dptr, &tmp_size) ) {
300
PyErr_SetString(PyExc_TypeError,
301
"dbm mappings have byte string elements only");
304
val.dsize = tmp_size;
307
if (dbm_store(dp->di_dbm, key, val, DBM_INSERT) < 0) {
308
dbm_clearerr(dp->di_dbm);
309
PyErr_SetString(DbmError, "cannot add item to database");
316
static PyMethodDef dbm_methods[] = {
317
{"close", (PyCFunction)dbm__close, METH_NOARGS,
318
"close()\nClose the database."},
319
{"keys", (PyCFunction)dbm_keys, METH_NOARGS,
320
"keys() -> list\nReturn a list of all keys in the database."},
321
{"get", (PyCFunction)dbm_get, METH_VARARGS,
322
"get(key[, default]) -> value\n"
323
"Return the value for key if present, otherwise default."},
324
{"setdefault", (PyCFunction)dbm_setdefault, METH_VARARGS,
325
"setdefault(key[, default]) -> value\n"
326
"Return the value for key if present, otherwise default. If key\n"
327
"is not in the database, it is inserted with default as the value."},
328
{NULL, NULL} /* sentinel */
331
static PyTypeObject Dbmtype = {
332
PyVarObject_HEAD_INIT(NULL, 0)
336
(destructor)dbm_dealloc, /*tp_dealloc*/
343
&dbm_as_sequence, /*tp_as_sequence*/
344
&dbm_as_mapping, /*tp_as_mapping*/
351
Py_TPFLAGS_DEFAULT, /*tp_flags*/
355
0, /*tp_richcompare*/
356
0, /*tp_weaklistoffset*/
359
dbm_methods, /*tp_methods*/
362
/* ----------------------------------------------------------------- */
365
dbmopen(PyObject *self, PyObject *args)
372
if ( !PyArg_ParseTuple(args, "s|si:open", &name, &flags, &mode) )
374
if ( strcmp(flags, "r") == 0 )
376
else if ( strcmp(flags, "w") == 0 )
378
else if ( strcmp(flags, "rw") == 0 ) /* B/W compat */
379
iflags = O_RDWR|O_CREAT;
380
else if ( strcmp(flags, "c") == 0 )
381
iflags = O_RDWR|O_CREAT;
382
else if ( strcmp(flags, "n") == 0 )
383
iflags = O_RDWR|O_CREAT|O_TRUNC;
385
PyErr_SetString(DbmError,
386
"arg 2 to open should be 'r', 'w', 'c', or 'n'");
389
return newdbmobject(name, iflags, mode);
392
static PyMethodDef dbmmodule_methods[] = {
393
{ "open", (PyCFunction)dbmopen, METH_VARARGS,
394
"open(path[, flag[, mode]]) -> mapping\n"
395
"Return a database object."},
400
static struct PyModuleDef _dbmmodule = {
401
PyModuleDef_HEAD_INIT,
416
if (PyType_Ready(&Dbmtype) < 0)
418
m = PyModule_Create(&_dbmmodule);
421
d = PyModule_GetDict(m);
422
if (DbmError == NULL)
423
DbmError = PyErr_NewException("_dbm.error",
424
PyExc_IOError, NULL);
425
s = PyUnicode_FromString(which_dbm);
427
PyDict_SetItemString(d, "library", s);
430
if (DbmError != NULL)
431
PyDict_SetItemString(d, "error", DbmError);
432
if (PyErr_Occurred()) {