From 9260e77386184bb89c447aaea5616d51acfa5023 Mon Sep 17 00:00:00 2001 From: Serhiy Storchaka Date: Fri, 17 Apr 2015 21:05:18 +0300 Subject: Issue #20184: Converted _dbm and _gdbm modules to Argument Clinic. --- Modules/_dbmmodule.c | 128 +++++++++-------- Modules/_gdbmmodule.c | 306 ++++++++++++++++++++++++----------------- Modules/clinic/_dbmmodule.c.h | 90 ++++++++++-- Modules/clinic/_gdbmmodule.c.h | 256 ++++++++++++++++++++++++++++++++++ 4 files changed, 580 insertions(+), 200 deletions(-) create mode 100644 Modules/clinic/_gdbmmodule.c.h 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]*/ -- cgit v0.12