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