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()) {