Issue #20184: Converted _dbm and _gdbm modules to Argument Clinic.

4 files changed, 580 insertions, 200 deletions

diff --git a/Modules/_dbmmodule.c b/Modules/_dbmmodule.c
index b815e97..6c605ea 100644
--- a/Modules/_dbmmodule.c
+++ b/Modules/_dbmmodule.c
@@ -29,10 +29,10 @@ static char *which_dbm = "Berkeley DB";
 #endif
 
 /*[clinic input]
-module dbm
-class dbm.dbm "dbmobject *" "&Dbmtype"
+module _dbm
+class _dbm.dbm "dbmobject *" "&Dbmtype"
 [clinic start generated code]*/
-/*[clinic end generated code: output=da39a3ee5e6b4b0d input=92450564684a69a3]*/
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=9b1aa8756d16150e]*/
 
 typedef struct {
     PyObject_HEAD
@@ -51,15 +51,6 @@ static PyTypeObject Dbmtype;
 
 static PyObject *DbmError;
 
-/*[python input]
-class dbmobject_converter(self_converter):
-    type = "dbmobject *"
-    def pre_render(self):
-        super().pre_render()
-        self.name = 'dp'
-[python start generated code]*/
-/*[python end generated code: output=da39a3ee5e6b4b0d input=6ad536357913879a]*/
-
 static PyObject *
 newdbmobject(const char *file, int flags, int mode)
 {
@@ -183,29 +174,43 @@ static PyMappingMethods dbm_as_mapping = {
     (objobjargproc)dbm_ass_sub,         /*mp_ass_subscript*/
 };
 
+/*[clinic input]
+_dbm.dbm.close
+
+Close the database.
+[clinic start generated code]*/
+
 static PyObject *
-dbm__close(dbmobject *dp, PyObject *unused)
+_dbm_dbm_close_impl(dbmobject *self)
+/*[clinic end generated code: output=c8dc5b6709600b86 input=046db72377d51be8]*/
 {
-    if (dp->di_dbm)
-        dbm_close(dp->di_dbm);
-    dp->di_dbm = NULL;
+    if (self->di_dbm)
+        dbm_close(self->di_dbm);
+    self->di_dbm = NULL;
     Py_INCREF(Py_None);
     return Py_None;
 }
 
+/*[clinic input]
+_dbm.dbm.keys
+
+Return a list of all keys in the database.
+[clinic start generated code]*/
+
 static PyObject *
-dbm_keys(dbmobject *dp, PyObject *unused)
+_dbm_dbm_keys_impl(dbmobject *self)
+/*[clinic end generated code: output=434549f7c121b33c input=d210ba778cd9c68a]*/
 {
     PyObject *v, *item;
     datum key;
     int err;
 
-    check_dbmobject_open(dp);
+    check_dbmobject_open(self);
     v = PyList_New(0);
     if (v == NULL)
         return NULL;
-    for (key = dbm_firstkey(dp->di_dbm); key.dptr;
-         key = dbm_nextkey(dp->di_dbm)) {
+    for (key = dbm_firstkey(self->di_dbm); key.dptr;
+         key = dbm_nextkey(self->di_dbm)) {
         item = PyBytes_FromStringAndSize(key.dptr, key.dsize);
         if (item == NULL) {
             Py_DECREF(v);
@@ -267,29 +272,26 @@ static PySequenceMethods dbm_as_sequence = {
 };
 
 /*[clinic input]
-
-dbm.dbm.get
-
-    self: dbmobject
+_dbm.dbm.get
 
     key: str(types={'str', 'robuffer'}, length=True)
-    default: object = None
+    default: object(c_default="NULL") = b''
     /
 
 Return the value for key if present, otherwise default.
 [clinic start generated code]*/
 
 static PyObject *
-dbm_dbm_get_impl(dbmobject *dp, const char *key, Py_ssize_clean_t key_length,
-                 PyObject *default_value)
-/*[clinic end generated code: output=4f5c0e523eaf1251 input=f81478bc211895ef]*/
+_dbm_dbm_get_impl(dbmobject *self, const char *key,
+                  Py_ssize_clean_t key_length, PyObject *default_value)
+/*[clinic end generated code: output=b44f95eba8203d93 input=fee97bbe85e84822]*/
 {
     datum dbm_key, val;
 
     dbm_key.dptr = (char *)key;
     dbm_key.dsize = key_length;
-    check_dbmobject_open(dp);
-    val = dbm_fetch(dp->di_dbm, dbm_key);
+    check_dbmobject_open(self);
+    val = dbm_fetch(self->di_dbm, dbm_key);
     if (val.dptr != NULL)
         return PyBytes_FromStringAndSize(val.dptr, val.dsize);
 
@@ -297,46 +299,55 @@ dbm_dbm_get_impl(dbmobject *dp, const char *key, Py_ssize_clean_t key_length,
     return default_value;
 }
 
+/*[clinic input]
+_dbm.dbm.setdefault
+    key: str(types={'str', 'robuffer'}, length=True)
+    default: object(c_default="NULL") = b''
+    /
+
+Return the value for key if present, otherwise default.
+
+If key is not in the database, it is inserted with default as the value.
+[clinic start generated code]*/
+
 static PyObject *
-dbm_setdefault(dbmobject *dp, PyObject *args)
+_dbm_dbm_setdefault_impl(dbmobject *self, const char *key,
+                         Py_ssize_clean_t key_length,
+                         PyObject *default_value)
+/*[clinic end generated code: output=52545886cf272161 input=6a3b99ae91f20203]*/
 {
-    datum key, val;
-    PyObject *defvalue = NULL;
-    char *tmp_ptr;
+    datum dbm_key, val;
     Py_ssize_t tmp_size;
 
-    if (!PyArg_ParseTuple(args, "s#|O:setdefault",
-                          &tmp_ptr, &tmp_size, &defvalue))
-        return NULL;
-    key.dptr = tmp_ptr;
-    key.dsize = tmp_size;
-    check_dbmobject_open(dp);
-    val = dbm_fetch(dp->di_dbm, key);
+    dbm_key.dptr = (char *)key;
+    dbm_key.dsize = key_length;
+    check_dbmobject_open(self);
+    val = dbm_fetch(self->di_dbm, dbm_key);
     if (val.dptr != NULL)
         return PyBytes_FromStringAndSize(val.dptr, val.dsize);
-    if (defvalue == NULL) {
-        defvalue = PyBytes_FromStringAndSize(NULL, 0);
-        if (defvalue == NULL)
+    if (default_value == NULL) {
+        default_value = PyBytes_FromStringAndSize(NULL, 0);
+        if (default_value == NULL)
             return NULL;
         val.dptr = NULL;
         val.dsize = 0;
     }
     else {
-        if ( !PyArg_Parse(defvalue, "s#", &val.dptr, &tmp_size) ) {
+        if ( !PyArg_Parse(default_value, "s#", &val.dptr, &tmp_size) ) {
             PyErr_SetString(PyExc_TypeError,
                 "dbm mappings have byte string elements only");
             return NULL;
         }
         val.dsize = tmp_size;
-        Py_INCREF(defvalue);
+        Py_INCREF(default_value);
     }
-    if (dbm_store(dp->di_dbm, key, val, DBM_INSERT) < 0) {
-        dbm_clearerr(dp->di_dbm);
+    if (dbm_store(self->di_dbm, dbm_key, val, DBM_INSERT) < 0) {
+        dbm_clearerr(self->di_dbm);
         PyErr_SetString(DbmError, "cannot add item to database");
-        Py_DECREF(defvalue);
+        Py_DECREF(default_value);
         return NULL;
     }
-    return defvalue;
+    return default_value;
 }
 
 static PyObject *
@@ -355,15 +366,10 @@ dbm__exit__(PyObject *self, PyObject *args)
 
 
 static PyMethodDef dbm_methods[] = {
-    {"close",           (PyCFunction)dbm__close,        METH_NOARGS,
-     "close()\nClose the database."},
-    {"keys",            (PyCFunction)dbm_keys,          METH_NOARGS,
-     "keys() -> list\nReturn a list of all keys in the database."},
-    DBM_DBM_GET_METHODDEF
-    {"setdefault",      (PyCFunction)dbm_setdefault,    METH_VARARGS,
-     "setdefault(key[, default]) -> value\n"
-     "Return the value for key if present, otherwise default.  If key\n"
-     "is not in the database, it is inserted with default as the value."},
+    _DBM_DBM_CLOSE_METHODDEF
+    _DBM_DBM_KEYS_METHODDEF
+    _DBM_DBM_GET_METHODDEF
+    _DBM_DBM_SETDEFAULT_METHODDEF
     {"__enter__", dbm__enter__, METH_NOARGS, NULL},
     {"__exit__",  dbm__exit__, METH_VARARGS, NULL},
     {NULL,              NULL}           /* sentinel */
@@ -404,7 +410,7 @@ static PyTypeObject Dbmtype = {
 
 /*[clinic input]
 
-dbm.open as dbmopen
+_dbm.open as dbmopen
 
     filename: str
         The filename to open.
@@ -425,7 +431,7 @@ Return a database object.
 static PyObject *
 dbmopen_impl(PyModuleDef *module, const char *filename, const char *flags,
              int mode)
-/*[clinic end generated code: output=e8d4b36f25c733fd input=6499ab0fab1333ac]*/
+/*[clinic end generated code: output=e8d4b36f25c733fd input=226334bade5764e6]*/
 {
     int iflags;
 
diff --git a/Modules/_gdbmmodule.c b/Modules/_gdbmmodule.c
index 229e16e..eb6da8e 100644
--- a/Modules/_gdbmmodule.c
+++ b/Modules/_gdbmmodule.c
@@ -16,17 +16,23 @@
 extern const char * gdbm_strerror(gdbm_error);
 #endif
 
+/*[clinic input]
+module _gdbm
+class _gdbm.gdbm "dbmobject *" "&Dbmtype"
+[clinic start generated code]*/
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=113927c6170729b2]*/
+
 PyDoc_STRVAR(gdbmmodule__doc__,
 "This module provides an interface to the GNU DBM (GDBM) library.\n\
 \n\
 This module is quite similar to the dbm module, but uses GDBM instead to\n\
-provide some additional functionality. Please note that the file formats\n\
-created by GDBM and dbm are incompatible. \n\
+provide some additional functionality.  Please note that the file formats\n\
+created by GDBM and dbm are incompatible.\n\
 \n\
 GDBM objects behave like mappings (dictionaries), except that keys and\n\
-values are always strings. Printing a GDBM object doesn't print the\n\
-keys and values, and the items() and values() methods are not\n\
-supported.");
+values are always immutable bytes-like objects or strings.  Printing\n\
+a GDBM object doesn't print the keys and values, and the items() and\n\
+values() methods are not supported.");
 
 typedef struct {
     PyObject_HEAD
@@ -36,6 +42,8 @@ typedef struct {
 
 static PyTypeObject Dbmtype;
 
+#include "clinic/_gdbmmodule.c.h"
+
 #define is_dbmobject(v) (Py_TYPE(v) == &Dbmtype)
 #define check_dbmobject_open(v) if ((v)->di_dbm == NULL) \
     { PyErr_SetString(DbmError, "GDBM object has already been closed"); \
@@ -48,15 +56,15 @@ static PyObject *DbmError;
 PyDoc_STRVAR(gdbm_object__doc__,
 "This object represents a GDBM database.\n\
 GDBM objects behave like mappings (dictionaries), except that keys and\n\
-values are always strings. Printing a GDBM object doesn't print the\n\
-keys and values, and the items() and values() methods are not\n\
-supported.\n\
+values are always immutable bytes-like objects or strings.  Printing\n\
+a GDBM object doesn't print the keys and values, and the items() and\n\
+values() methods are not supported.\n\
 \n\
 GDBM objects also support additional operations such as firstkey,\n\
 nextkey, reorganize, and sync.");
 
 static PyObject *
-newdbmobject(char *file, int flags, int mode)
+newdbmobject(const char *file, int flags, int mode)
 {
     dbmobject *dp;
 
@@ -65,7 +73,7 @@ newdbmobject(char *file, int flags, int mode)
         return NULL;
     dp->di_size = -1;
     errno = 0;
-    if ((dp->di_dbm = gdbm_open(file, 0, flags, mode, NULL)) == 0) {
+    if ((dp->di_dbm = gdbm_open((char *)file, 0, flags, mode, NULL)) == 0) {
         if (errno != 0)
             PyErr_SetFromErrno(DbmError);
         else
@@ -135,24 +143,27 @@ dbm_subscript(dbmobject *dp, PyObject *key)
     return v;
 }
 
-PyDoc_STRVAR(dbm_get__doc__,
-"get(key[, default]) -> value\n\
-Get the value for key, or default if not present; if not given,\n\
-default is None.");
+/*[clinic input]
+_gdbm.gdbm.get
+
+    key: object
+    default: object = None
+    /
+
+Get the value for key, or default if not present.
+[clinic start generated code]*/
 
 static PyObject *
-dbm_get(dbmobject *dp, PyObject *args)
+_gdbm_gdbm_get_impl(dbmobject *self, PyObject *key, PyObject *default_value)
+/*[clinic end generated code: output=19b7c585ad4f554a input=a9c20423f34c17b6]*/
 {
-    PyObject *v, *res;
-    PyObject *def = Py_None;
+    PyObject *res;
 
-    if (!PyArg_UnpackTuple(args, "get", 1, 2, &v, &def))
-        return NULL;
-    res = dbm_subscript(dp, v);
+    res = dbm_subscript(self, key);
     if (res == NULL && PyErr_ExceptionMatches(PyExc_KeyError)) {
         PyErr_Clear();
-        Py_INCREF(def);
-        return def;
+        Py_INCREF(default_value);
+        return default_value;
     }
     return res;
 }
@@ -198,25 +209,29 @@ dbm_ass_sub(dbmobject *dp, PyObject *v, PyObject *w)
     return 0;
 }
 
-PyDoc_STRVAR(dbm_setdefault__doc__,
-"setdefault(key[, default]) -> value\n\
-Get value for key, or set it to default and return default if not present;\n\
-if not given, default is None.");
+/*[clinic input]
+_gdbm.gdbm.setdefault
+
+    key: object
+    default: object = None
+    /
+
+Get value for key, or set it to default and return default if not present.
+[clinic start generated code]*/
 
 static PyObject *
-dbm_setdefault(dbmobject *dp, PyObject *args)
+_gdbm_gdbm_setdefault_impl(dbmobject *self, PyObject *key,
+                           PyObject *default_value)
+/*[clinic end generated code: output=88760ee520329012 input=0db46b69e9680171]*/
 {
-    PyObject *v, *res;
-    PyObject *def = Py_None;
+    PyObject *res;
 
-    if (!PyArg_UnpackTuple(args, "setdefault", 1, 2, &v, &def))
-        return NULL;
-    res = dbm_subscript(dp, v);
+    res = dbm_subscript(self, key);
     if (res == NULL && PyErr_ExceptionMatches(PyExc_KeyError)) {
         PyErr_Clear();
-        if (dbm_ass_sub(dp, v, def) < 0)
+        if (dbm_ass_sub(self, key, default_value) < 0)
             return NULL;
-        return dbm_subscript(dp, v);
+        return dbm_subscript(self, key);
     }
     return res;
 }
@@ -227,43 +242,49 @@ static PyMappingMethods dbm_as_mapping = {
     (objobjargproc)dbm_ass_sub,         /*mp_ass_subscript*/
 };
 
-PyDoc_STRVAR(dbm_close__doc__,
-"close() -> None\n\
-Closes the database.");
+/*[clinic input]
+_gdbm.gdbm.close
+
+Close the database.
+[clinic start generated code]*/
 
 static PyObject *
-dbm_close(dbmobject *dp, PyObject *unused)
+_gdbm_gdbm_close_impl(dbmobject *self)
+/*[clinic end generated code: output=23512a594598b563 input=0a203447379b45fd]*/
 {
-    if (dp->di_dbm)
-        gdbm_close(dp->di_dbm);
-    dp->di_dbm = NULL;
+    if (self->di_dbm)
+        gdbm_close(self->di_dbm);
+    self->di_dbm = NULL;
     Py_INCREF(Py_None);
     return Py_None;
 }
 
 /* XXX Should return a set or a set view */
-PyDoc_STRVAR(dbm_keys__doc__,
-"keys() -> list_of_keys\n\
-Get a list of all keys in the database.");
+/*[clinic input]
+_gdbm.gdbm.keys
+
+Get a list of all keys in the database.
+[clinic start generated code]*/
 
 static PyObject *
-dbm_keys(dbmobject *dp, PyObject *unused)
+_gdbm_gdbm_keys_impl(dbmobject *self)
+/*[clinic end generated code: output=cb4b1776c3645dcc input=1832ee0a3132cfaf]*/
 {
     PyObject *v, *item;
     datum key, nextkey;
     int err;
 
-    if (dp == NULL || !is_dbmobject(dp)) {
+    if (self == NULL || !is_dbmobject(self)) {
         PyErr_BadInternalCall();
         return NULL;
     }
-    check_dbmobject_open(dp);
+    check_dbmobject_open(self);
 
     v = PyList_New(0);
     if (v == NULL)
         return NULL;
 
-    key = gdbm_firstkey(dp->di_dbm);
+    key = gdbm_firstkey(self->di_dbm);
     while (key.dptr) {
         item = PyBytes_FromStringAndSize(key.dptr, key.dsize);
         if (item == NULL) {
@@ -278,7 +299,7 @@ dbm_keys(dbmobject *dp, PyObject *unused)
             Py_DECREF(v);
             return NULL;
         }
-        nextkey = gdbm_nextkey(dp->di_dbm, key);
+        nextkey = gdbm_nextkey(self->di_dbm, key);
         free(key.dptr);
         key = nextkey;
     }
@@ -329,21 +350,25 @@ static PySequenceMethods dbm_as_sequence = {
         0,                      /* sq_inplace_repeat */
 };
 
-PyDoc_STRVAR(dbm_firstkey__doc__,
-"firstkey() -> key\n\
-It's possible to loop over every key in the database using this method\n\
-and the nextkey() method. The traversal is ordered by GDBM's internal\n\
-hash values, and won't be sorted by the key values. This method\n\
-returns the starting key.");
+/*[clinic input]
+_gdbm.gdbm.firstkey
+
+Return the starting key for the traversal.
+
+It's possible to loop over every key in the database using this method
+and the nextkey() method.  The traversal is ordered by GDBM's internal
+hash values, and won't be sorted by the key values.
+[clinic start generated code]*/
 
 static PyObject *
-dbm_firstkey(dbmobject *dp, PyObject *unused)
+_gdbm_gdbm_firstkey_impl(dbmobject *self)
+/*[clinic end generated code: output=9ff85628d84b65d2 input=0dbd6a335d69bba0]*/
 {
     PyObject *v;
     datum key;
 
-    check_dbmobject_open(dp);
-    key = gdbm_firstkey(dp->di_dbm);
+    check_dbmobject_open(self);
+    key = gdbm_firstkey(self->di_dbm);
     if (key.dptr) {
         v = PyBytes_FromStringAndSize(key.dptr, key.dsize);
         free(key.dptr);
@@ -355,27 +380,35 @@ dbm_firstkey(dbmobject *dp, PyObject *unused)
     }
 }
 
-PyDoc_STRVAR(dbm_nextkey__doc__,
-"nextkey(key) -> next_key\n\
-Returns the key that follows key in the traversal.\n\
-The following code prints every key in the database db, without having\n\
-to create a list in memory that contains them all:\n\
-\n\
-      k = db.firstkey()\n\
-      while k != None:\n\
-          print k\n\
-          k = db.nextkey(k)");
+/*[clinic input]
+_gdbm.gdbm.nextkey
+
+    key: str(types={'str', 'robuffer'}, length=True)
+    /
+
+Returns the key that follows key in the traversal.
+
+The following code prints every key in the database db, without having
+to create a list in memory that contains them all:
+
+      k = db.firstkey()
+      while k != None:
+          print(k)
+          k = db.nextkey(k)
+[clinic start generated code]*/
 
 static PyObject *
-dbm_nextkey(dbmobject *dp, PyObject *args)
+_gdbm_gdbm_nextkey_impl(dbmobject *self, const char *key,
+                        Py_ssize_clean_t key_length)
+/*[clinic end generated code: output=192ab892de6eb2f6 input=df8e8828201214a6]*/
 {
     PyObject *v;
-    datum key, nextkey;
+    datum dbm_key, nextkey;
 
-    if (!PyArg_ParseTuple(args, "s#:nextkey", &key.dptr, &key.dsize))
-        return NULL;
-    check_dbmobject_open(dp);
-    nextkey = gdbm_nextkey(dp->di_dbm, key);
+    dbm_key.dptr = (char *)key;
+    dbm_key.dsize = key_length;
+    check_dbmobject_open(self);
+    nextkey = gdbm_nextkey(self->di_dbm, dbm_key);
     if (nextkey.dptr) {
         v = PyBytes_FromStringAndSize(nextkey.dptr, nextkey.dsize);
         free(nextkey.dptr);
@@ -387,20 +420,25 @@ dbm_nextkey(dbmobject *dp, PyObject *args)
     }
 }
 
-PyDoc_STRVAR(dbm_reorganize__doc__,
-"reorganize() -> None\n\
-If you have carried out a lot of deletions and would like to shrink\n\
-the space used by the GDBM file, this routine will reorganize the\n\
-database. GDBM will not shorten the length of a database file except\n\
-by using this reorganization; otherwise, deleted file space will be\n\
-kept and reused as new (key,value) pairs are added.");
+/*[clinic input]
+_gdbm.gdbm.reorganize
+
+Reorganize the database.
+
+If you have carried out a lot of deletions and would like to shrink
+the space used by the GDBM file, this routine will reorganize the
+database.  GDBM will not shorten the length of a database file except
+by using this reorganization; otherwise, deleted file space will be
+kept and reused as new (key,value) pairs are added.
+[clinic start generated code]*/
 
 static PyObject *
-dbm_reorganize(dbmobject *dp, PyObject *unused)
+_gdbm_gdbm_reorganize_impl(dbmobject *self)
+/*[clinic end generated code: output=38d9624df92e961d input=f6bea85bcfd40dd2]*/
 {
-    check_dbmobject_open(dp);
+    check_dbmobject_open(self);
     errno = 0;
-    if (gdbm_reorganize(dp->di_dbm) < 0) {
+    if (gdbm_reorganize(self->di_dbm) < 0) {
         if (errno != 0)
             PyErr_SetFromErrno(DbmError);
         else
@@ -411,16 +449,21 @@ dbm_reorganize(dbmobject *dp, PyObject *unused)
     return Py_None;
 }
 
-PyDoc_STRVAR(dbm_sync__doc__,
-"sync() -> None\n\
-When the database has been opened in fast mode, this method forces\n\
-any unwritten data to be written to the disk.");
+/*[clinic input]
+_gdbm.gdbm.sync
+
+Flush the database to the disk file.
+
+When the database has been opened in fast mode, this method forces
+any unwritten data to be written to the disk.
+[clinic start generated code]*/
 
 static PyObject *
-dbm_sync(dbmobject *dp, PyObject *unused)
+_gdbm_gdbm_sync_impl(dbmobject *self)
+/*[clinic end generated code: output=488b15f47028f125 input=2a47d2c9e153ab8a]*/
 {
-    check_dbmobject_open(dp);
-    gdbm_sync(dp->di_dbm);
+    check_dbmobject_open(self);
+    gdbm_sync(self->di_dbm);
     Py_INCREF(Py_None);
     return Py_None;
 }
@@ -440,14 +483,15 @@ dbm__exit__(PyObject *self, PyObject *args)
 }
 
 static PyMethodDef dbm_methods[] = {
-    {"close",     (PyCFunction)dbm_close,   METH_NOARGS, dbm_close__doc__},
-    {"keys",      (PyCFunction)dbm_keys,    METH_NOARGS, dbm_keys__doc__},
-    {"firstkey",  (PyCFunction)dbm_firstkey,METH_NOARGS, dbm_firstkey__doc__},
-    {"nextkey",   (PyCFunction)dbm_nextkey, METH_VARARGS, dbm_nextkey__doc__},
-    {"reorganize",(PyCFunction)dbm_reorganize,METH_NOARGS, dbm_reorganize__doc__},
-    {"sync",      (PyCFunction)dbm_sync,    METH_NOARGS, dbm_sync__doc__},
-    {"get",       (PyCFunction)dbm_get,     METH_VARARGS, dbm_get__doc__},
-    {"setdefault",(PyCFunction)dbm_setdefault,METH_VARARGS, dbm_setdefault__doc__},
+    _GDBM_GDBM_CLOSE_METHODDEF
+    _GDBM_GDBM_KEYS_METHODDEF
+    _GDBM_GDBM_FIRSTKEY_METHODDEF
+    _GDBM_GDBM_NEXTKEY_METHODDEF
+    _GDBM_GDBM_REORGANIZE_METHODDEF
+    _GDBM_GDBM_SYNC_METHODDEF
+    _GDBM_GDBM_GET_METHODDEF
+    _GDBM_GDBM_GET_METHODDEF
+    _GDBM_GDBM_SETDEFAULT_METHODDEF
     {"__enter__", dbm__enter__, METH_NOARGS, NULL},
     {"__exit__",  dbm__exit__, METH_VARARGS, NULL},
     {NULL,              NULL}           /* sentinel */
@@ -486,40 +530,44 @@ static PyTypeObject Dbmtype = {
 
 /* ----------------------------------------------------------------- */
 
-PyDoc_STRVAR(dbmopen__doc__,
-"open(filename, [flags, [mode]])  -> dbm_object\n\
-Open a dbm database and return a dbm object. The filename argument is\n\
-the name of the database file.\n\
-\n\
-The optional flags argument can be 'r' (to open an existing database\n\
-for reading only -- default), 'w' (to open an existing database for\n\
-reading and writing), 'c' (which creates the database if it doesn't\n\
-exist), or 'n' (which always creates a new empty database).\n\
-\n\
-Some versions of gdbm support additional flags which must be\n\
-appended to one of the flags described above. The module constant\n\
-'open_flags' is a string of valid additional flags. The 'f' flag\n\
-opens the database in fast mode; altered data will not automatically\n\
-be written to the disk after every change. This results in faster\n\
-writes to the database, but may result in an inconsistent database\n\
-if the program crashes while the database is still open. Use the\n\
-sync() method to force any unwritten data to be written to the disk.\n\
-The 's' flag causes all database operations to be synchronized to\n\
-disk. The 'u' flag disables locking of the database file.\n\
-\n\
-The optional mode argument is the Unix mode of the file, used only\n\
-when the database has to be created. It defaults to octal 0666. ");
+/*[clinic input]
+_gdbm.open as dbmopen
+    filename as name: str
+    flags: str="r"
+    mode: int(py_default="0o666") = 0o666
+    /
+
+Open a dbm database and return a dbm object.
+
+The filename argument is the name of the database file.
+
+The optional flags argument can be 'r' (to open an existing database
+for reading only -- default), 'w' (to open an existing database for
+reading and writing), 'c' (which creates the database if it doesn't
+exist), or 'n' (which always creates a new empty database).
+
+Some versions of gdbm support additional flags which must be
+appended to one of the flags described above.  The module constant
+'open_flags' is a string of valid additional flags.  The 'f' flag
+opens the database in fast mode; altered data will not automatically
+be written to the disk after every change.  This results in faster
+writes to the database, but may result in an inconsistent database
+if the program crashes while the database is still open.  Use the
+sync() method to force any unwritten data to be written to the disk.
+The 's' flag causes all database operations to be synchronized to
+disk.  The 'u' flag disables locking of the database file.
+
+The optional mode argument is the Unix mode of the file, used only
+when the database has to be created.  It defaults to octal 0o666.
+[clinic start generated code]*/
 
 static PyObject *
-dbmopen(PyObject *self, PyObject *args)
+dbmopen_impl(PyModuleDef *module, const char *name, const char *flags,
+             int mode)
+/*[clinic end generated code: output=365b31415c03ccd4 input=55563cd60e51984a]*/
 {
-    char *name;
-    char *flags = "r";
     int iflags;
-    int mode = 0666;
 
-    if (!PyArg_ParseTuple(args, "s|si:open", &name, &flags, &mode))
-        return NULL;
     switch (flags[0]) {
     case 'r':
         iflags = GDBM_READER;
@@ -580,7 +628,7 @@ static char dbmmodule_open_flags[] = "rwcn"
                                      ;
 
 static PyMethodDef dbmmodule_methods[] = {
-    { "open", (PyCFunction)dbmopen, METH_VARARGS, dbmopen__doc__},
+    DBMOPEN_METHODDEF
     { 0, 0 },
 };
 
diff --git a/Modules/clinic/_dbmmodule.c.h b/Modules/clinic/_dbmmodule.c.h
index c5f4c5a..4d88373 100644
--- a/Modules/clinic/_dbmmodule.c.h
+++ b/Modules/clinic/_dbmmodule.c.h
@@ -2,32 +2,102 @@
 preserve
 [clinic start generated code]*/
 
-PyDoc_STRVAR(dbm_dbm_get__doc__,
-"get($self, key, default=None, /)\n"
+PyDoc_STRVAR(_dbm_dbm_close__doc__,
+"close($self, /)\n"
+"--\n"
+"\n"
+"Close the database.");
+
+#define _DBM_DBM_CLOSE_METHODDEF    \
+    {"close", (PyCFunction)_dbm_dbm_close, METH_NOARGS, _dbm_dbm_close__doc__},
+
+static PyObject *
+_dbm_dbm_close_impl(dbmobject *self);
+
+static PyObject *
+_dbm_dbm_close(dbmobject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _dbm_dbm_close_impl(self);
+}
+
+PyDoc_STRVAR(_dbm_dbm_keys__doc__,
+"keys($self, /)\n"
+"--\n"
+"\n"
+"Return a list of all keys in the database.");
+
+#define _DBM_DBM_KEYS_METHODDEF    \
+    {"keys", (PyCFunction)_dbm_dbm_keys, METH_NOARGS, _dbm_dbm_keys__doc__},
+
+static PyObject *
+_dbm_dbm_keys_impl(dbmobject *self);
+
+static PyObject *
+_dbm_dbm_keys(dbmobject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _dbm_dbm_keys_impl(self);
+}
+
+PyDoc_STRVAR(_dbm_dbm_get__doc__,
+"get($self, key, default=b\'\', /)\n"
 "--\n"
 "\n"
 "Return the value for key if present, otherwise default.");
 
-#define DBM_DBM_GET_METHODDEF    \
-    {"get", (PyCFunction)dbm_dbm_get, METH_VARARGS, dbm_dbm_get__doc__},
+#define _DBM_DBM_GET_METHODDEF    \
+    {"get", (PyCFunction)_dbm_dbm_get, METH_VARARGS, _dbm_dbm_get__doc__},
 
 static PyObject *
-dbm_dbm_get_impl(dbmobject *dp, const char *key, Py_ssize_clean_t key_length,
-                 PyObject *default_value);
+_dbm_dbm_get_impl(dbmobject *self, const char *key,
+                  Py_ssize_clean_t key_length, PyObject *default_value);
 
 static PyObject *
-dbm_dbm_get(dbmobject *dp, PyObject *args)
+_dbm_dbm_get(dbmobject *self, PyObject *args)
 {
     PyObject *return_value = NULL;
     const char *key;
     Py_ssize_clean_t key_length;
-    PyObject *default_value = Py_None;
+    PyObject *default_value = NULL;
 
     if (!PyArg_ParseTuple(args,
         "s#|O:get",
         &key, &key_length, &default_value))
         goto exit;
-    return_value = dbm_dbm_get_impl(dp, key, key_length, default_value);
+    return_value = _dbm_dbm_get_impl(self, key, key_length, default_value);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_dbm_dbm_setdefault__doc__,
+"setdefault($self, key, default=b\'\', /)\n"
+"--\n"
+"\n"
+"Return the value for key if present, otherwise default.\n"
+"\n"
+"If key is not in the database, it is inserted with default as the value.");
+
+#define _DBM_DBM_SETDEFAULT_METHODDEF    \
+    {"setdefault", (PyCFunction)_dbm_dbm_setdefault, METH_VARARGS, _dbm_dbm_setdefault__doc__},
+
+static PyObject *
+_dbm_dbm_setdefault_impl(dbmobject *self, const char *key,
+                         Py_ssize_clean_t key_length,
+                         PyObject *default_value);
+
+static PyObject *
+_dbm_dbm_setdefault(dbmobject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    const char *key;
+    Py_ssize_clean_t key_length;
+    PyObject *default_value = NULL;
+
+    if (!PyArg_ParseTuple(args,
+        "s#|O:setdefault",
+        &key, &key_length, &default_value))
+        goto exit;
+    return_value = _dbm_dbm_setdefault_impl(self, key, key_length, default_value);
 
 exit:
     return return_value;
@@ -71,4 +141,4 @@ dbmopen(PyModuleDef *module, PyObject *args)
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=d6ec55c6c5d0b19d input=a9049054013a1b77]*/
+/*[clinic end generated code: output=951fcfdb6d667a61 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_gdbmmodule.c.h b/Modules/clinic/_gdbmmodule.c.h
new file mode 100644
index 0000000..d9e9acf
--- /dev/null
+++ b/Modules/clinic/_gdbmmodule.c.h
@@ -0,0 +1,256 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_gdbm_gdbm_get__doc__,
+"get($self, key, default=None, /)\n"
+"--\n"
+"\n"
+"Get the value for key, or default if not present.");
+
+#define _GDBM_GDBM_GET_METHODDEF    \
+    {"get", (PyCFunction)_gdbm_gdbm_get, METH_VARARGS, _gdbm_gdbm_get__doc__},
+
+static PyObject *
+_gdbm_gdbm_get_impl(dbmobject *self, PyObject *key, PyObject *default_value);
+
+static PyObject *
+_gdbm_gdbm_get(dbmobject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *key;
+    PyObject *default_value = Py_None;
+
+    if (!PyArg_UnpackTuple(args, "get",
+        1, 2,
+        &key, &default_value))
+        goto exit;
+    return_value = _gdbm_gdbm_get_impl(self, key, default_value);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_gdbm_gdbm_setdefault__doc__,
+"setdefault($self, key, default=None, /)\n"
+"--\n"
+"\n"
+"Get value for key, or set it to default and return default if not present.");
+
+#define _GDBM_GDBM_SETDEFAULT_METHODDEF    \
+    {"setdefault", (PyCFunction)_gdbm_gdbm_setdefault, METH_VARARGS, _gdbm_gdbm_setdefault__doc__},
+
+static PyObject *
+_gdbm_gdbm_setdefault_impl(dbmobject *self, PyObject *key,
+                           PyObject *default_value);
+
+static PyObject *
+_gdbm_gdbm_setdefault(dbmobject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *key;
+    PyObject *default_value = Py_None;
+
+    if (!PyArg_UnpackTuple(args, "setdefault",
+        1, 2,
+        &key, &default_value))
+        goto exit;
+    return_value = _gdbm_gdbm_setdefault_impl(self, key, default_value);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_gdbm_gdbm_close__doc__,
+"close($self, /)\n"
+"--\n"
+"\n"
+"Close the database.");
+
+#define _GDBM_GDBM_CLOSE_METHODDEF    \
+    {"close", (PyCFunction)_gdbm_gdbm_close, METH_NOARGS, _gdbm_gdbm_close__doc__},
+
+static PyObject *
+_gdbm_gdbm_close_impl(dbmobject *self);
+
+static PyObject *
+_gdbm_gdbm_close(dbmobject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _gdbm_gdbm_close_impl(self);
+}
+
+PyDoc_STRVAR(_gdbm_gdbm_keys__doc__,
+"keys($self, /)\n"
+"--\n"
+"\n"
+"Get a list of all keys in the database.");
+
+#define _GDBM_GDBM_KEYS_METHODDEF    \
+    {"keys", (PyCFunction)_gdbm_gdbm_keys, METH_NOARGS, _gdbm_gdbm_keys__doc__},
+
+static PyObject *
+_gdbm_gdbm_keys_impl(dbmobject *self);
+
+static PyObject *
+_gdbm_gdbm_keys(dbmobject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _gdbm_gdbm_keys_impl(self);
+}
+
+PyDoc_STRVAR(_gdbm_gdbm_firstkey__doc__,
+"firstkey($self, /)\n"
+"--\n"
+"\n"
+"Return the starting key for the traversal.\n"
+"\n"
+"It\'s possible to loop over every key in the database using this method\n"
+"and the nextkey() method.  The traversal is ordered by GDBM\'s internal\n"
+"hash values, and won\'t be sorted by the key values.");
+
+#define _GDBM_GDBM_FIRSTKEY_METHODDEF    \
+    {"firstkey", (PyCFunction)_gdbm_gdbm_firstkey, METH_NOARGS, _gdbm_gdbm_firstkey__doc__},
+
+static PyObject *
+_gdbm_gdbm_firstkey_impl(dbmobject *self);
+
+static PyObject *
+_gdbm_gdbm_firstkey(dbmobject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _gdbm_gdbm_firstkey_impl(self);
+}
+
+PyDoc_STRVAR(_gdbm_gdbm_nextkey__doc__,
+"nextkey($self, key, /)\n"
+"--\n"
+"\n"
+"Returns the key that follows key in the traversal.\n"
+"\n"
+"The following code prints every key in the database db, without having\n"
+"to create a list in memory that contains them all:\n"
+"\n"
+"      k = db.firstkey()\n"
+"      while k != None:\n"
+"          print(k)\n"
+"          k = db.nextkey(k)");
+
+#define _GDBM_GDBM_NEXTKEY_METHODDEF    \
+    {"nextkey", (PyCFunction)_gdbm_gdbm_nextkey, METH_O, _gdbm_gdbm_nextkey__doc__},
+
+static PyObject *
+_gdbm_gdbm_nextkey_impl(dbmobject *self, const char *key,
+                        Py_ssize_clean_t key_length);
+
+static PyObject *
+_gdbm_gdbm_nextkey(dbmobject *self, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    const char *key;
+    Py_ssize_clean_t key_length;
+
+    if (!PyArg_Parse(arg,
+        "s#:nextkey",
+        &key, &key_length))
+        goto exit;
+    return_value = _gdbm_gdbm_nextkey_impl(self, key, key_length);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_gdbm_gdbm_reorganize__doc__,
+"reorganize($self, /)\n"
+"--\n"
+"\n"
+"Reorganize the database.\n"
+"\n"
+"If you have carried out a lot of deletions and would like to shrink\n"
+"the space used by the GDBM file, this routine will reorganize the\n"
+"database.  GDBM will not shorten the length of a database file except\n"
+"by using this reorganization; otherwise, deleted file space will be\n"
+"kept and reused as new (key,value) pairs are added.");
+
+#define _GDBM_GDBM_REORGANIZE_METHODDEF    \
+    {"reorganize", (PyCFunction)_gdbm_gdbm_reorganize, METH_NOARGS, _gdbm_gdbm_reorganize__doc__},
+
+static PyObject *
+_gdbm_gdbm_reorganize_impl(dbmobject *self);
+
+static PyObject *
+_gdbm_gdbm_reorganize(dbmobject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _gdbm_gdbm_reorganize_impl(self);
+}
+
+PyDoc_STRVAR(_gdbm_gdbm_sync__doc__,
+"sync($self, /)\n"
+"--\n"
+"\n"
+"Flush the database to the disk file.\n"
+"\n"
+"When the database has been opened in fast mode, this method forces\n"
+"any unwritten data to be written to the disk.");
+
+#define _GDBM_GDBM_SYNC_METHODDEF    \
+    {"sync", (PyCFunction)_gdbm_gdbm_sync, METH_NOARGS, _gdbm_gdbm_sync__doc__},
+
+static PyObject *
+_gdbm_gdbm_sync_impl(dbmobject *self);
+
+static PyObject *
+_gdbm_gdbm_sync(dbmobject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _gdbm_gdbm_sync_impl(self);
+}
+
+PyDoc_STRVAR(dbmopen__doc__,
+"open($module, filename, flags=\'r\', mode=0o666, /)\n"
+"--\n"
+"\n"
+"Open a dbm database and return a dbm object.\n"
+"\n"
+"The filename argument is the name of the database file.\n"
+"\n"
+"The optional flags argument can be \'r\' (to open an existing database\n"
+"for reading only -- default), \'w\' (to open an existing database for\n"
+"reading and writing), \'c\' (which creates the database if it doesn\'t\n"
+"exist), or \'n\' (which always creates a new empty database).\n"
+"\n"
+"Some versions of gdbm support additional flags which must be\n"
+"appended to one of the flags described above.  The module constant\n"
+"\'open_flags\' is a string of valid additional flags.  The \'f\' flag\n"
+"opens the database in fast mode; altered data will not automatically\n"
+"be written to the disk after every change.  This results in faster\n"
+"writes to the database, but may result in an inconsistent database\n"
+"if the program crashes while the database is still open.  Use the\n"
+"sync() method to force any unwritten data to be written to the disk.\n"
+"The \'s\' flag causes all database operations to be synchronized to\n"
+"disk.  The \'u\' flag disables locking of the database file.\n"
+"\n"
+"The optional mode argument is the Unix mode of the file, used only\n"
+"when the database has to be created.  It defaults to octal 0o666.");
+
+#define DBMOPEN_METHODDEF    \
+    {"open", (PyCFunction)dbmopen, METH_VARARGS, dbmopen__doc__},
+
+static PyObject *
+dbmopen_impl(PyModuleDef *module, const char *name, const char *flags,
+             int mode);
+
+static PyObject *
+dbmopen(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    const char *name;
+    const char *flags = "r";
+    int mode = 438;
+
+    if (!PyArg_ParseTuple(args,
+        "s|si:open",
+        &name, &flags, &mode))
+        goto exit;
+    return_value = dbmopen_impl(module, name, flags, mode);
+
+exit:
+    return return_value;
+}
+/*[clinic end generated code: output=b41c68a5f30699cb input=a9049054013a1b77]*/