Branch data Line data Source code
1 : :
2 : : /* DBM module using dictionary interface */
3 : :
4 : :
5 : : #define PY_SSIZE_T_CLEAN
6 : : #include "Python.h"
7 : :
8 : : #include <sys/types.h>
9 : : #include <sys/stat.h>
10 : : #include <fcntl.h>
11 : :
12 : : /* Some Linux systems install gdbm/ndbm.h, but not ndbm.h. This supports
13 : : * whichever configure was able to locate.
14 : : */
15 : : #if defined(USE_GDBM_COMPAT)
16 : : #ifdef HAVE_GDBM_NDBM_H
17 : : #include <gdbm/ndbm.h>
18 : : #elif HAVE_GDBM_DASH_NDBM_H
19 : : #include <gdbm-ndbm.h>
20 : : #else
21 : : #error "No gdbm/ndbm.h or gdbm-ndbm.h available"
22 : : #endif
23 : : static const char which_dbm[] = "GNU gdbm";
24 : : #elif defined(USE_NDBM)
25 : : #include <ndbm.h>
26 : : static const char which_dbm[] = "GNU gdbm";
27 : : #elif defined(USE_BERKDB)
28 : : #ifndef DB_DBM_HSEARCH
29 : : #define DB_DBM_HSEARCH 1
30 : : #endif
31 : : #include <db.h>
32 : : static const char which_dbm[] = "Berkeley DB";
33 : : #else
34 : : #error "No ndbm.h available!"
35 : : #endif
36 : :
37 : : typedef struct {
38 : : PyTypeObject *dbm_type;
39 : : PyObject *dbm_error;
40 : : } _dbm_state;
41 : :
42 : : static inline _dbm_state*
43 : 548 : get_dbm_state(PyObject *module)
44 : : {
45 : 548 : void *state = PyModule_GetState(module);
46 : : assert(state != NULL);
47 : 548 : return (_dbm_state *)state;
48 : : }
49 : :
50 : : /*[clinic input]
51 : : module _dbm
52 : : class _dbm.dbm "dbmobject *" "&Dbmtype"
53 : : [clinic start generated code]*/
54 : : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=9b1aa8756d16150e]*/
55 : :
56 : : typedef struct {
57 : : PyObject_HEAD
58 : : int flags;
59 : : int di_size; /* -1 means recompute */
60 : : DBM *di_dbm;
61 : : } dbmobject;
62 : :
63 : : #include "clinic/_dbmmodule.c.h"
64 : :
65 : : #define check_dbmobject_open(v, err) \
66 : : if ((v)->di_dbm == NULL) { \
67 : : PyErr_SetString(err, "DBM object has already been closed"); \
68 : : return NULL; \
69 : : }
70 : :
71 : : static PyObject *
72 : 209 : newdbmobject(_dbm_state *state, const char *file, int flags, int mode)
73 : : {
74 : 209 : dbmobject *dp = PyObject_GC_New(dbmobject, state->dbm_type);
75 [ - + ]: 209 : if (dp == NULL) {
76 : 0 : return NULL;
77 : : }
78 : 209 : dp->di_size = -1;
79 : 209 : dp->flags = flags;
80 : 209 : PyObject_GC_Track(dp);
81 : :
82 : : /* See issue #19296 */
83 [ + + ]: 209 : if ( (dp->di_dbm = dbm_open((char *)file, flags, mode)) == 0 ) {
84 : 5 : PyErr_SetFromErrnoWithFilename(state->dbm_error, file);
85 : 5 : Py_DECREF(dp);
86 : 5 : return NULL;
87 : : }
88 : 204 : return (PyObject *)dp;
89 : : }
90 : :
91 : : /* Methods */
92 : : static int
93 : 14 : dbm_traverse(dbmobject *dp, visitproc visit, void *arg)
94 : : {
95 [ + - - + ]: 14 : Py_VISIT(Py_TYPE(dp));
96 : 14 : return 0;
97 : : }
98 : :
99 : : static void
100 : 209 : dbm_dealloc(dbmobject *dp)
101 : : {
102 : 209 : PyObject_GC_UnTrack(dp);
103 [ - + ]: 209 : if (dp->di_dbm) {
104 : 0 : dbm_close(dp->di_dbm);
105 : : }
106 : 209 : PyTypeObject *tp = Py_TYPE(dp);
107 : 209 : tp->tp_free(dp);
108 : 209 : Py_DECREF(tp);
109 : 209 : }
110 : :
111 : : static Py_ssize_t
112 : 121 : dbm_length(dbmobject *dp)
113 : : {
114 : 121 : _dbm_state *state = PyType_GetModuleState(Py_TYPE(dp));
115 : : assert(state != NULL);
116 [ - + ]: 121 : if (dp->di_dbm == NULL) {
117 : 0 : PyErr_SetString(state->dbm_error, "DBM object has already been closed");
118 : 0 : return -1;
119 : : }
120 [ + + ]: 121 : if ( dp->di_size < 0 ) {
121 : : datum key;
122 : : int size;
123 : :
124 : 85 : size = 0;
125 [ + + ]: 139 : for ( key=dbm_firstkey(dp->di_dbm); key.dptr;
126 : 54 : key = dbm_nextkey(dp->di_dbm))
127 : 54 : size++;
128 : 85 : dp->di_size = size;
129 : : }
130 : 121 : return dp->di_size;
131 : : }
132 : :
133 : : static PyObject *
134 : 334 : dbm_subscript(dbmobject *dp, PyObject *key)
135 : : {
136 : : datum drec, krec;
137 : : Py_ssize_t tmp_size;
138 : 334 : _dbm_state *state = PyType_GetModuleState(Py_TYPE(dp));
139 : : assert(state != NULL);
140 [ - + ]: 334 : if (!PyArg_Parse(key, "s#", &krec.dptr, &tmp_size)) {
141 : 0 : return NULL;
142 : : }
143 : :
144 : 334 : krec.dsize = tmp_size;
145 [ - + ]: 334 : check_dbmobject_open(dp, state->dbm_error);
146 : 334 : drec = dbm_fetch(dp->di_dbm, krec);
147 [ + + ]: 334 : if ( drec.dptr == 0 ) {
148 : 51 : PyErr_SetObject(PyExc_KeyError, key);
149 : 51 : return NULL;
150 : : }
151 [ - + ]: 283 : if ( dbm_error(dp->di_dbm) ) {
152 : 0 : dbm_clearerr(dp->di_dbm);
153 : 0 : PyErr_SetString(state->dbm_error, "");
154 : 0 : return NULL;
155 : : }
156 : 283 : return PyBytes_FromStringAndSize(drec.dptr, drec.dsize);
157 : : }
158 : :
159 : : static int
160 : 203 : dbm_ass_sub(dbmobject *dp, PyObject *v, PyObject *w)
161 : : {
162 : : datum krec, drec;
163 : : Py_ssize_t tmp_size;
164 : :
165 [ - + ]: 203 : if ( !PyArg_Parse(v, "s#", &krec.dptr, &tmp_size) ) {
166 : 0 : PyErr_SetString(PyExc_TypeError,
167 : : "dbm mappings have bytes or string keys only");
168 : 0 : return -1;
169 : : }
170 : 203 : _dbm_state *state = PyType_GetModuleState(Py_TYPE(dp));
171 : : assert(state != NULL);
172 : 203 : krec.dsize = tmp_size;
173 [ - + ]: 203 : if (dp->di_dbm == NULL) {
174 : 0 : PyErr_SetString(state->dbm_error, "DBM object has already been closed");
175 : 0 : return -1;
176 : : }
177 : 203 : dp->di_size = -1;
178 [ + + ]: 203 : if (w == NULL) {
179 [ + + ]: 44 : if ( dbm_delete(dp->di_dbm, krec) < 0 ) {
180 : 2 : dbm_clearerr(dp->di_dbm);
181 : : /* we might get a failure for reasons like file corrupted,
182 : : but we are not able to distinguish it */
183 [ - + ]: 2 : if (dp->flags & O_RDWR) {
184 : 0 : PyErr_SetObject(PyExc_KeyError, v);
185 : : }
186 : : else {
187 : 2 : PyErr_SetString(state->dbm_error, "cannot delete item from database");
188 : : }
189 : 2 : return -1;
190 : : }
191 : : } else {
192 [ - + ]: 159 : if ( !PyArg_Parse(w, "s#", &drec.dptr, &tmp_size) ) {
193 : 0 : PyErr_SetString(PyExc_TypeError,
194 : : "dbm mappings have bytes or string elements only");
195 : 0 : return -1;
196 : : }
197 : 159 : drec.dsize = tmp_size;
198 [ + + ]: 159 : if ( dbm_store(dp->di_dbm, krec, drec, DBM_REPLACE) < 0 ) {
199 : 1 : dbm_clearerr(dp->di_dbm);
200 : 1 : PyErr_SetString(state->dbm_error,
201 : : "cannot add item to database");
202 : 1 : return -1;
203 : : }
204 : : }
205 [ - + ]: 200 : if ( dbm_error(dp->di_dbm) ) {
206 : 0 : dbm_clearerr(dp->di_dbm);
207 : 0 : PyErr_SetString(state->dbm_error, "");
208 : 0 : return -1;
209 : : }
210 : 200 : return 0;
211 : : }
212 : :
213 : : /*[clinic input]
214 : : _dbm.dbm.close
215 : :
216 : : Close the database.
217 : : [clinic start generated code]*/
218 : :
219 : : static PyObject *
220 : 204 : _dbm_dbm_close_impl(dbmobject *self)
221 : : /*[clinic end generated code: output=c8dc5b6709600b86 input=046db72377d51be8]*/
222 : : {
223 [ + - ]: 204 : if (self->di_dbm) {
224 : 204 : dbm_close(self->di_dbm);
225 : : }
226 : 204 : self->di_dbm = NULL;
227 : 204 : Py_RETURN_NONE;
228 : : }
229 : :
230 : : /*[clinic input]
231 : : _dbm.dbm.keys
232 : :
233 : : cls: defining_class
234 : :
235 : : Return a list of all keys in the database.
236 : : [clinic start generated code]*/
237 : :
238 : : static PyObject *
239 : 252 : _dbm_dbm_keys_impl(dbmobject *self, PyTypeObject *cls)
240 : : /*[clinic end generated code: output=f2a593b3038e5996 input=d3706a28fc051097]*/
241 : : {
242 : : PyObject *v, *item;
243 : : datum key;
244 : : int err;
245 : :
246 : 252 : _dbm_state *state = PyType_GetModuleState(cls);
247 : : assert(state != NULL);
248 [ + + ]: 252 : check_dbmobject_open(self, state->dbm_error);
249 : 251 : v = PyList_New(0);
250 [ - + ]: 251 : if (v == NULL) {
251 : 0 : return NULL;
252 : : }
253 [ + + ]: 538 : for (key = dbm_firstkey(self->di_dbm); key.dptr;
254 : 287 : key = dbm_nextkey(self->di_dbm)) {
255 : 287 : item = PyBytes_FromStringAndSize(key.dptr, key.dsize);
256 [ - + ]: 287 : if (item == NULL) {
257 : 0 : Py_DECREF(v);
258 : 0 : return NULL;
259 : : }
260 : 287 : err = PyList_Append(v, item);
261 : 287 : Py_DECREF(item);
262 [ - + ]: 287 : if (err != 0) {
263 : 0 : Py_DECREF(v);
264 : 0 : return NULL;
265 : : }
266 : : }
267 : 251 : return v;
268 : : }
269 : :
270 : : static int
271 : 79 : dbm_contains(PyObject *self, PyObject *arg)
272 : : {
273 : 79 : dbmobject *dp = (dbmobject *)self;
274 : : datum key, val;
275 : : Py_ssize_t size;
276 : :
277 : 79 : _dbm_state *state = PyType_GetModuleState(Py_TYPE(dp));
278 : : assert(state != NULL);
279 [ - + ]: 79 : if ((dp)->di_dbm == NULL) {
280 : 0 : PyErr_SetString(state->dbm_error,
281 : : "DBM object has already been closed");
282 : 0 : return -1;
283 : : }
284 [ + + ]: 79 : if (PyUnicode_Check(arg)) {
285 : 2 : key.dptr = (char *)PyUnicode_AsUTF8AndSize(arg, &size);
286 : 2 : key.dsize = size;
287 [ - + ]: 2 : if (key.dptr == NULL)
288 : 0 : return -1;
289 : : }
290 [ - + ]: 77 : else if (!PyBytes_Check(arg)) {
291 : 0 : PyErr_Format(PyExc_TypeError,
292 : : "dbm key must be bytes or string, not %.100s",
293 : 0 : Py_TYPE(arg)->tp_name);
294 : 0 : return -1;
295 : : }
296 : : else {
297 : 77 : key.dptr = PyBytes_AS_STRING(arg);
298 : 77 : key.dsize = PyBytes_GET_SIZE(arg);
299 : : }
300 : 79 : val = dbm_fetch(dp->di_dbm, key);
301 : 79 : return val.dptr != NULL;
302 : : }
303 : :
304 : : /*[clinic input]
305 : : _dbm.dbm.get
306 : : cls: defining_class
307 : : key: str(accept={str, robuffer}, zeroes=True)
308 : : default: object = None
309 : : /
310 : :
311 : : Return the value for key if present, otherwise default.
312 : : [clinic start generated code]*/
313 : :
314 : : static PyObject *
315 : 8 : _dbm_dbm_get_impl(dbmobject *self, PyTypeObject *cls, const char *key,
316 : : Py_ssize_t key_length, PyObject *default_value)
317 : : /*[clinic end generated code: output=b4e55f8b6d482bc4 input=66b993b8349fa8c1]*/
318 : : {
319 : : datum dbm_key, val;
320 : 8 : _dbm_state *state = PyType_GetModuleState(cls);
321 : : assert(state != NULL);
322 : 8 : dbm_key.dptr = (char *)key;
323 : 8 : dbm_key.dsize = key_length;
324 [ - + ]: 8 : check_dbmobject_open(self, state->dbm_error);
325 : 8 : val = dbm_fetch(self->di_dbm, dbm_key);
326 [ + + ]: 8 : if (val.dptr != NULL) {
327 : 4 : return PyBytes_FromStringAndSize(val.dptr, val.dsize);
328 : : }
329 : :
330 : 4 : Py_INCREF(default_value);
331 : 4 : return default_value;
332 : : }
333 : :
334 : : /*[clinic input]
335 : : _dbm.dbm.setdefault
336 : : cls: defining_class
337 : : key: str(accept={str, robuffer}, zeroes=True)
338 : : default: object(c_default="NULL") = b''
339 : : /
340 : :
341 : : Return the value for key if present, otherwise default.
342 : :
343 : : If key is not in the database, it is inserted with default as the value.
344 : : [clinic start generated code]*/
345 : :
346 : : static PyObject *
347 : 4 : _dbm_dbm_setdefault_impl(dbmobject *self, PyTypeObject *cls, const char *key,
348 : : Py_ssize_t key_length, PyObject *default_value)
349 : : /*[clinic end generated code: output=9c2f6ea6d0fb576c input=126a3ff15c5f8232]*/
350 : : {
351 : : datum dbm_key, val;
352 : : Py_ssize_t tmp_size;
353 : 4 : _dbm_state *state = PyType_GetModuleState(cls);
354 : : assert(state != NULL);
355 : 4 : dbm_key.dptr = (char *)key;
356 : 4 : dbm_key.dsize = key_length;
357 [ - + ]: 4 : check_dbmobject_open(self, state->dbm_error);
358 : 4 : val = dbm_fetch(self->di_dbm, dbm_key);
359 [ + + ]: 4 : if (val.dptr != NULL) {
360 : 2 : return PyBytes_FromStringAndSize(val.dptr, val.dsize);
361 : : }
362 [ - + ]: 2 : if (default_value == NULL) {
363 : 0 : default_value = PyBytes_FromStringAndSize(NULL, 0);
364 [ # # ]: 0 : if (default_value == NULL) {
365 : 0 : return NULL;
366 : : }
367 : 0 : val.dptr = NULL;
368 : 0 : val.dsize = 0;
369 : : }
370 : : else {
371 [ - + ]: 2 : if ( !PyArg_Parse(default_value, "s#", &val.dptr, &tmp_size) ) {
372 : 0 : PyErr_SetString(PyExc_TypeError,
373 : : "dbm mappings have bytes or string elements only");
374 : 0 : return NULL;
375 : : }
376 : 2 : val.dsize = tmp_size;
377 : 2 : Py_INCREF(default_value);
378 : : }
379 [ - + ]: 2 : if (dbm_store(self->di_dbm, dbm_key, val, DBM_INSERT) < 0) {
380 : 0 : dbm_clearerr(self->di_dbm);
381 : 0 : PyErr_SetString(state->dbm_error, "cannot add item to database");
382 : 0 : Py_DECREF(default_value);
383 : 0 : return NULL;
384 : : }
385 : 2 : return default_value;
386 : : }
387 : :
388 : : static PyObject *
389 : 14 : dbm__enter__(PyObject *self, PyObject *args)
390 : : {
391 : 14 : Py_INCREF(self);
392 : 14 : return self;
393 : : }
394 : :
395 : : static PyObject *
396 : 14 : dbm__exit__(PyObject *self, PyObject *args)
397 : : {
398 : 14 : return _dbm_dbm_close_impl((dbmobject *)self);
399 : : }
400 : :
401 : : static PyMethodDef dbm_methods[] = {
402 : : _DBM_DBM_CLOSE_METHODDEF
403 : : _DBM_DBM_KEYS_METHODDEF
404 : : _DBM_DBM_GET_METHODDEF
405 : : _DBM_DBM_SETDEFAULT_METHODDEF
406 : : {"__enter__", dbm__enter__, METH_NOARGS, NULL},
407 : : {"__exit__", dbm__exit__, METH_VARARGS, NULL},
408 : : {NULL, NULL} /* sentinel */
409 : : };
410 : :
411 : : static PyType_Slot dbmtype_spec_slots[] = {
412 : : {Py_tp_dealloc, dbm_dealloc},
413 : : {Py_tp_traverse, dbm_traverse},
414 : : {Py_tp_methods, dbm_methods},
415 : : {Py_sq_contains, dbm_contains},
416 : : {Py_mp_length, dbm_length},
417 : : {Py_mp_subscript, dbm_subscript},
418 : : {Py_mp_ass_subscript, dbm_ass_sub},
419 : : {0, 0}
420 : : };
421 : :
422 : :
423 : : static PyType_Spec dbmtype_spec = {
424 : : .name = "_dbm.dbm",
425 : : .basicsize = sizeof(dbmobject),
426 : : // Calling PyType_GetModuleState() on a subclass is not safe.
427 : : // dbmtype_spec does not have Py_TPFLAGS_BASETYPE flag
428 : : // which prevents to create a subclass.
429 : : // So calling PyType_GetModuleState() in this file is always safe.
430 : : .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION |
431 : : Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE),
432 : : .slots = dbmtype_spec_slots,
433 : : };
434 : :
435 : : /* ----------------------------------------------------------------- */
436 : :
437 : : /*[clinic input]
438 : :
439 : : _dbm.open as dbmopen
440 : :
441 : : filename: object
442 : : The filename to open.
443 : :
444 : : flags: str="r"
445 : : How to open the file. "r" for reading, "w" for writing, etc.
446 : :
447 : : mode: int(py_default="0o666") = 0o666
448 : : If creating a new file, the mode bits for the new file
449 : : (e.g. os.O_RDWR).
450 : :
451 : : /
452 : :
453 : : Return a database object.
454 : :
455 : : [clinic start generated code]*/
456 : :
457 : : static PyObject *
458 : 209 : dbmopen_impl(PyObject *module, PyObject *filename, const char *flags,
459 : : int mode)
460 : : /*[clinic end generated code: output=9527750f5df90764 input=d8cf50a9f81218c8]*/
461 : : {
462 : : int iflags;
463 : 209 : _dbm_state *state = get_dbm_state(module);
464 : : assert(state != NULL);
465 [ + + ]: 209 : if (strcmp(flags, "r") == 0) {
466 : 14 : iflags = O_RDONLY;
467 : : }
468 [ + + ]: 195 : else if (strcmp(flags, "w") == 0) {
469 : 2 : iflags = O_RDWR;
470 : : }
471 [ + + ]: 193 : else if (strcmp(flags, "rw") == 0) {
472 : : /* Backward compatibility */
473 : 1 : iflags = O_RDWR|O_CREAT;
474 : : }
475 [ + + ]: 192 : else if (strcmp(flags, "c") == 0) {
476 : 186 : iflags = O_RDWR|O_CREAT;
477 : : }
478 [ + - ]: 6 : else if (strcmp(flags, "n") == 0) {
479 : 6 : iflags = O_RDWR|O_CREAT|O_TRUNC;
480 : : }
481 : : else {
482 : 0 : PyErr_SetString(state->dbm_error,
483 : : "arg 2 to open should be 'r', 'w', 'c', or 'n'");
484 : 0 : return NULL;
485 : : }
486 : :
487 : : PyObject *filenamebytes;
488 [ - + ]: 209 : if (!PyUnicode_FSConverter(filename, &filenamebytes)) {
489 : 0 : return NULL;
490 : : }
491 : :
492 : 209 : const char *name = PyBytes_AS_STRING(filenamebytes);
493 [ - + ]: 209 : if (strlen(name) != (size_t)PyBytes_GET_SIZE(filenamebytes)) {
494 : 0 : Py_DECREF(filenamebytes);
495 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
496 : 0 : return NULL;
497 : : }
498 : 209 : PyObject *self = newdbmobject(state, name, iflags, mode);
499 : 209 : Py_DECREF(filenamebytes);
500 : 209 : return self;
501 : : }
502 : :
503 : : static PyMethodDef dbmmodule_methods[] = {
504 : : DBMOPEN_METHODDEF
505 : : { 0, 0 },
506 : : };
507 : :
508 : : static int
509 : 11 : _dbm_exec(PyObject *module)
510 : : {
511 : 11 : _dbm_state *state = get_dbm_state(module);
512 : 11 : state->dbm_type = (PyTypeObject *)PyType_FromModuleAndSpec(module,
513 : : &dbmtype_spec, NULL);
514 [ - + ]: 11 : if (state->dbm_type == NULL) {
515 : 0 : return -1;
516 : : }
517 : 11 : state->dbm_error = PyErr_NewException("_dbm.error", PyExc_OSError, NULL);
518 [ - + ]: 11 : if (state->dbm_error == NULL) {
519 : 0 : return -1;
520 : : }
521 [ - + ]: 11 : if (PyModule_AddStringConstant(module, "library", which_dbm) < 0) {
522 : 0 : return -1;
523 : : }
524 [ - + ]: 11 : if (PyModule_AddType(module, (PyTypeObject *)state->dbm_error) < 0) {
525 : 0 : return -1;
526 : : }
527 : 11 : return 0;
528 : : }
529 : :
530 : : static int
531 : 306 : _dbm_module_traverse(PyObject *module, visitproc visit, void *arg)
532 : : {
533 : 306 : _dbm_state *state = get_dbm_state(module);
534 [ + - - + ]: 306 : Py_VISIT(state->dbm_error);
535 [ + - - + ]: 306 : Py_VISIT(state->dbm_type);
536 : 306 : return 0;
537 : : }
538 : :
539 : : static int
540 : 22 : _dbm_module_clear(PyObject *module)
541 : : {
542 : 22 : _dbm_state *state = get_dbm_state(module);
543 [ + + ]: 22 : Py_CLEAR(state->dbm_error);
544 [ + + ]: 22 : Py_CLEAR(state->dbm_type);
545 : 22 : return 0;
546 : : }
547 : :
548 : : static void
549 : 11 : _dbm_module_free(void *module)
550 : : {
551 : 11 : _dbm_module_clear((PyObject *)module);
552 : 11 : }
553 : :
554 : : static PyModuleDef_Slot _dbmmodule_slots[] = {
555 : : {Py_mod_exec, _dbm_exec},
556 : : {0, NULL}
557 : : };
558 : :
559 : : static struct PyModuleDef _dbmmodule = {
560 : : PyModuleDef_HEAD_INIT,
561 : : .m_name = "_dbm",
562 : : .m_size = sizeof(_dbm_state),
563 : : .m_methods = dbmmodule_methods,
564 : : .m_slots = _dbmmodule_slots,
565 : : .m_traverse = _dbm_module_traverse,
566 : : .m_clear = _dbm_module_clear,
567 : : .m_free = _dbm_module_free,
568 : : };
569 : :
570 : : PyMODINIT_FUNC
571 : 11 : PyInit__dbm(void)
572 : : {
573 : 11 : return PyModuleDef_Init(&_dbmmodule);
574 : : }
|
