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