Skip to content

C
cpython
Kaydet (Commit) e3a41c65 authored tarafından Fred Drake's avatar Fred Drake
Dosyalara gözat
Seçenekler

ANSI-fy the sources. 

Convert to using PyArg_ParseTuple() as appropriate to allow method names
in error messages.
Re-indent to four-space indentation.
üst 0c89d4ec
Hide whitespace changes
Inline Side-by-side
Showing with 287 additions and 313 deletions
Modules/gdbmmodule.c
Dosyayı görüntüle @ e3a41c65
...@@ -38,17 +38,17 @@ keys and values, and the items() and values() methods are not\n\ ...@@ -38,17 +38,17 @@ keys and values, and the items() and values() methods are not\n\
supported."; supported.";
typedef struct { typedef struct {
PyObject_HEAD PyObject_HEAD
int di_size; /* -1 means recompute */ int di_size; /* -1 means recompute */
GDBM_FILE di_dbm; GDBM_FILE di_dbm;
} dbmobject; } dbmobject;
staticforward PyTypeObject Dbmtype; staticforward PyTypeObject Dbmtype;
#define is_dbmobject(v) ((v)->ob_type == &Dbmtype) #define is_dbmobject(v) ((v)->ob_type == &Dbmtype)
#define check_dbmobject_open(v) if ((v)->di_dbm == NULL) \ #define check_dbmobject_open(v) if ((v)->di_dbm == NULL) \
{ PyErr_SetString(DbmError, "GDBM object has already been closed"); \ { PyErr_SetString(DbmError, "GDBM object has already been closed"); \
return NULL; } return NULL; }
...@@ -65,139 +65,131 @@ GDBM objects also support additional operations such as firstkey,\n\ ...@@ -65,139 +65,131 @@ GDBM objects also support additional operations such as firstkey,\n\
nextkey, reorganize, and sync."; nextkey, reorganize, and sync.";
static PyObject * static PyObject *
newdbmobject(file, flags, mode) newdbmobject(char *file, int flags, int mode)
char *file;
int flags;
int mode;
{ {
dbmobject *dp; dbmobject *dp;
dp = PyObject_New(dbmobject, &Dbmtype); dp = PyObject_New(dbmobject, &Dbmtype);
if (dp == NULL) if (dp == NULL)
return NULL; return NULL;
dp->di_size = -1; dp->di_size = -1;
errno = 0; errno = 0;
if ( (dp->di_dbm = gdbm_open(file, 0, flags, mode, NULL)) == 0 ) { if ((dp->di_dbm = gdbm_open(file, 0, flags, mode, NULL)) == 0) {
if (errno != 0) if (errno != 0)
PyErr_SetFromErrno(DbmError); PyErr_SetFromErrno(DbmError);
else else
PyErr_SetString(DbmError, gdbm_strerror(gdbm_errno)); PyErr_SetString(DbmError, gdbm_strerror(gdbm_errno));
Py_DECREF(dp); Py_DECREF(dp);
return NULL; return NULL;
} }
return (PyObject *)dp; return (PyObject *)dp;
} }
/* Methods */ /* Methods */
static void static void
dbm_dealloc(dp) dbm_dealloc(register dbmobject *dp)
register dbmobject *dp;
{ {
if ( dp->di_dbm ) if (dp->di_dbm)
gdbm_close(dp->di_dbm); gdbm_close(dp->di_dbm);
PyObject_Del(dp); PyObject_Del(dp);
} }
static int static int
dbm_length(dp) dbm_length(dbmobject *dp)
dbmobject *dp;
{ {
if (dp->di_dbm == NULL) { if (dp->di_dbm == NULL) {
PyErr_SetString(DbmError, "GDBM object has already been closed"); PyErr_SetString(DbmError, "GDBM object has already been closed");
return -1; return -1;
}
if (dp->di_size < 0) {
datum key,okey;
int size;
okey.dsize=0;
size = 0;
for (key=gdbm_firstkey(dp->di_dbm); key.dptr;
key = gdbm_nextkey(dp->di_dbm,okey)) {
size++;
if(okey.dsize) free(okey.dptr);
okey=key;
} }
if ( dp->di_size < 0 ) { dp->di_size = size;
datum key,okey; }
int size; return dp->di_size;
okey.dsize=0;
size = 0;
for ( key=gdbm_firstkey(dp->di_dbm); key.dptr;
key = gdbm_nextkey(dp->di_dbm,okey)) {
size++;
if(okey.dsize) free(okey.dptr);
okey=key;
}
dp->di_size = size;
}
return dp->di_size;
} }
static PyObject * static PyObject *
dbm_subscript(dp, key) dbm_subscript(dbmobject *dp, register PyObject *key)
dbmobject *dp;
register PyObject *key;
{ {
PyObject *v; PyObject *v;
datum drec, krec; datum drec, krec;
if (!PyArg_Parse(key, "s#", &krec.dptr, &krec.dsize) ) if (!PyArg_Parse(key, "s#", &krec.dptr, &krec.dsize) )
return NULL; return NULL;
if (dp->di_dbm == NULL) { if (dp->di_dbm == NULL) {
PyErr_SetString(DbmError, PyErr_SetString(DbmError,
"GDBM object has already been closed"); "GDBM object has already been closed");
return NULL; return NULL;
} }
drec = gdbm_fetch(dp->di_dbm, krec); drec = gdbm_fetch(dp->di_dbm, krec);
if ( drec.dptr == 0 ) { if (drec.dptr == 0) {
PyErr_SetString(PyExc_KeyError, PyErr_SetString(PyExc_KeyError,
PyString_AS_STRING((PyStringObject *)key)); PyString_AS_STRING((PyStringObject *)key));
return NULL; return NULL;
} }
v = PyString_FromStringAndSize(drec.dptr, drec.dsize); v = PyString_FromStringAndSize(drec.dptr, drec.dsize);
free(drec.dptr); free(drec.dptr);
return v; return v;
} }
static int static int
dbm_ass_sub(dp, v, w) dbm_ass_sub(dbmobject *dp, PyObject *v, PyObject *w)
dbmobject *dp;
PyObject *v, *w;
{ {
datum krec, drec; datum krec, drec;
if ( !PyArg_Parse(v, "s#", &krec.dptr, &krec.dsize) ) { if (!PyArg_Parse(v, "s#", &krec.dptr, &krec.dsize) ) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"gdbm mappings have string indices only"); "gdbm mappings have string indices only");
return -1; return -1;
} }
if (dp->di_dbm == NULL) { if (dp->di_dbm == NULL) {
PyErr_SetString(DbmError, PyErr_SetString(DbmError,
"GDBM object has already been closed"); "GDBM object has already been closed");
return -1; return -1;
}
dp->di_size = -1;
if (w == NULL) {
if (gdbm_delete(dp->di_dbm, krec) < 0) {
PyErr_SetString(PyExc_KeyError,
PyString_AS_STRING((PyStringObject *)v));
return -1;
} }
dp->di_size = -1; }
if (w == NULL) { else {
if ( gdbm_delete(dp->di_dbm, krec) < 0 ) { if (!PyArg_Parse(w, "s#", &drec.dptr, &drec.dsize)) {
PyErr_SetString(PyExc_KeyError, PyErr_SetString(PyExc_TypeError,
PyString_AS_STRING((PyStringObject *)v)); "gdbm mappings have string elements only");
return -1; return -1;
} }
} else { errno = 0;
if ( !PyArg_Parse(w, "s#", &drec.dptr, &drec.dsize) ) { if (gdbm_store(dp->di_dbm, krec, drec, GDBM_REPLACE) < 0) {
PyErr_SetString(PyExc_TypeError, if (errno != 0)
"gdbm mappings have string elements only"); PyErr_SetFromErrno(DbmError);
return -1; else
} PyErr_SetString(DbmError,
errno = 0; gdbm_strerror(gdbm_errno));
if ( gdbm_store(dp->di_dbm, krec, drec, GDBM_REPLACE) < 0 ) { return -1;
if (errno != 0) }
PyErr_SetFromErrno(DbmError); }
else return 0;
PyErr_SetString(DbmError,
gdbm_strerror(gdbm_errno));
return -1;
}
}
return 0;
} }
static PyMappingMethods dbm_as_mapping = { static PyMappingMethods dbm_as_mapping = {
(inquiry)dbm_length, /*mp_length*/ (inquiry)dbm_length, /*mp_length*/
(binaryfunc)dbm_subscript, /*mp_subscript*/ (binaryfunc)dbm_subscript, /*mp_subscript*/
(objobjargproc)dbm_ass_sub, /*mp_ass_subscript*/ (objobjargproc)dbm_ass_sub, /*mp_ass_subscript*/
}; };
static char dbm_close__doc__[] = "\ static char dbm_close__doc__[] = "\
...@@ -205,17 +197,15 @@ close() -> None\n\ ...@@ -205,17 +197,15 @@ close() -> None\n\
Closes the database."; Closes the database.";
static PyObject * static PyObject *
dbm_close(dp, args) dbm_close(register dbmobject *dp, PyObject *args)
register dbmobject *dp;
PyObject *args;
{ {
if ( !PyArg_NoArgs(args) ) if (!PyArg_ParseTuple(args, ":close"))
return NULL; return NULL;
if ( dp->di_dbm ) if (dp->di_dbm)
gdbm_close(dp->di_dbm); gdbm_close(dp->di_dbm);
dp->di_dbm = NULL; dp->di_dbm = NULL;
Py_INCREF(Py_None); Py_INCREF(Py_None);
return Py_None; return Py_None;
} }
static char dbm_keys__doc__[] = "\ static char dbm_keys__doc__[] = "\
...@@ -223,49 +213,45 @@ keys() -> list_of_keys\n\ ...@@ -223,49 +213,45 @@ keys() -> list_of_keys\n\
Get a list of all keys in the database."; Get a list of all keys in the database.";
static PyObject * static PyObject *
dbm_keys(dp, args) dbm_keys(register dbmobject *dp, PyObject *args)
register dbmobject *dp;
PyObject *args;
{ {
register PyObject *v, *item; register PyObject *v, *item;
datum key, nextkey; datum key, nextkey;
int err; int err;
if (dp == NULL || !is_dbmobject(dp)) { if (dp == NULL || !is_dbmobject(dp)) {
PyErr_BadInternalCall(); PyErr_BadInternalCall();
return NULL; return NULL;
} }
if (!PyArg_ParseTuple(args, ":keys"))
if (!PyArg_NoArgs(args)) return NULL;
return NULL;
check_dbmobject_open(dp);
check_dbmobject_open(dp);
v = PyList_New(0);
v = PyList_New(0); if (v == NULL)
if (v == NULL) return NULL;
return NULL;
key = gdbm_firstkey(dp->di_dbm);
key = gdbm_firstkey(dp->di_dbm); while (key.dptr) {
while (key.dptr) { item = PyString_FromStringAndSize(key.dptr, key.dsize);
item = PyString_FromStringAndSize(key.dptr, key.dsize); if (item == NULL) {
if (item == NULL) { free(key.dptr);
free(key.dptr); Py_DECREF(v);
Py_DECREF(v); return NULL;
return NULL; }
} err = PyList_Append(v, item);
err = PyList_Append(v, item); Py_DECREF(item);
Py_DECREF(item); if (err != 0) {
if (err != 0) { free(key.dptr);
free(key.dptr); Py_DECREF(v);
Py_DECREF(v); return NULL;
return NULL; }
} nextkey = gdbm_nextkey(dp->di_dbm, key);
nextkey = gdbm_nextkey(dp->di_dbm, key); free(key.dptr);
free(key.dptr); key = nextkey;
key = nextkey; }
} return v;
return v;
} }
static char dbm_has_key__doc__[] = "\ static char dbm_has_key__doc__[] = "\
...@@ -273,16 +259,14 @@ has_key(key) -> boolean\n\ ...@@ -273,16 +259,14 @@ has_key(key) -> boolean\n\
Find out whether or not the database contains a given key."; Find out whether or not the database contains a given key.";
static PyObject * static PyObject *
dbm_has_key(dp, args) dbm_has_key(register dbmobject *dp, PyObject *args)
register dbmobject *dp;
PyObject *args;
{ {
datum key; datum key;
if (!PyArg_Parse(args, "s#", &key.dptr, &key.dsize)) if (!PyArg_ParseTuple(args, "s#:has_key", &key.dptr, &key.dsize))
return NULL; return NULL;
check_dbmobject_open(dp); check_dbmobject_open(dp);
return PyInt_FromLong((long) gdbm_exists(dp->di_dbm, key)); return PyInt_FromLong((long) gdbm_exists(dp->di_dbm, key));
} }
static char dbm_firstkey__doc__[] = "\ static char dbm_firstkey__doc__[] = "\
...@@ -293,25 +277,24 @@ hash values, and won't be sorted by the key values. This method\n\ ...@@ -293,25 +277,24 @@ hash values, and won't be sorted by the key values. This method\n\
returns the starting key."; returns the starting key.";
static PyObject * static PyObject *
dbm_firstkey(dp, args) dbm_firstkey(register dbmobject *dp, PyObject *args)
register dbmobject *dp;
PyObject *args;
{ {
register PyObject *v; register PyObject *v;
datum key; datum key;
if (!PyArg_NoArgs(args)) if (!PyArg_ParseTuple(args, ":firstkey"))
return NULL; return NULL;
check_dbmobject_open(dp); check_dbmobject_open(dp);
key = gdbm_firstkey(dp->di_dbm); key = gdbm_firstkey(dp->di_dbm);
if (key.dptr) { if (key.dptr) {
v = PyString_FromStringAndSize(key.dptr, key.dsize); v = PyString_FromStringAndSize(key.dptr, key.dsize);
free(key.dptr); free(key.dptr);
return v; return v;
} else { }
Py_INCREF(Py_None); else {
return Py_None; Py_INCREF(Py_None);
} return Py_None;
}
} }
static char dbm_nextkey__doc__[] = "\ static char dbm_nextkey__doc__[] = "\
...@@ -326,25 +309,24 @@ to create a list in memory that contains them all:\n\ ...@@ -326,25 +309,24 @@ to create a list in memory that contains them all:\n\
k = db.nextkey(k)"; k = db.nextkey(k)";
static PyObject * static PyObject *
dbm_nextkey(dp, args) dbm_nextkey(register dbmobject *dp, PyObject *args)
register dbmobject *dp;
PyObject *args;
{ {
register PyObject *v; register PyObject *v;
datum key, nextkey; datum key, nextkey;
if (!PyArg_Parse(args, "s#", &key.dptr, &key.dsize)) if (!PyArg_ParseTuple(args, "s#:nextkey", &key.dptr, &key.dsize))
return NULL; return NULL;
check_dbmobject_open(dp); check_dbmobject_open(dp);
nextkey = gdbm_nextkey(dp->di_dbm, key); nextkey = gdbm_nextkey(dp->di_dbm, key);
if (nextkey.dptr) { if (nextkey.dptr) {
v = PyString_FromStringAndSize(nextkey.dptr, nextkey.dsize); v = PyString_FromStringAndSize(nextkey.dptr, nextkey.dsize);
free(nextkey.dptr); free(nextkey.dptr);
return v; return v;
} else { }
Py_INCREF(Py_None); else {
return Py_None; Py_INCREF(Py_None);
} return Py_None;
}
} }
static char dbm_reorganize__doc__[] = "\ static char dbm_reorganize__doc__[] = "\
...@@ -356,23 +338,21 @@ by using this reorganization; otherwise, deleted file space will be\n\ ...@@ -356,23 +338,21 @@ by using this reorganization; otherwise, deleted file space will be\n\
kept and reused as new (key,value) pairs are added."; kept and reused as new (key,value) pairs are added.";
static PyObject * static PyObject *
dbm_reorganize(dp, args) dbm_reorganize(register dbmobject *dp, PyObject *args)
register dbmobject *dp;
PyObject *args;
{ {
if (!PyArg_NoArgs(args)) if (!PyArg_ParseTuple(args, ":reorganize"))
return NULL; return NULL;
check_dbmobject_open(dp); check_dbmobject_open(dp);
errno = 0; errno = 0;
if (gdbm_reorganize(dp->di_dbm) < 0) { if (gdbm_reorganize(dp->di_dbm) < 0) {
if (errno != 0) if (errno != 0)
PyErr_SetFromErrno(DbmError); PyErr_SetFromErrno(DbmError);
else else
PyErr_SetString(DbmError, gdbm_strerror(gdbm_errno)); PyErr_SetString(DbmError, gdbm_strerror(gdbm_errno));
return NULL; return NULL;
} }
Py_INCREF(Py_None); Py_INCREF(Py_None);
return Py_None; return Py_None;
} }
static char dbm_sync__doc__[] = "\ static char dbm_sync__doc__[] = "\
...@@ -381,60 +361,56 @@ When the database has been opened in fast mode, this method forces\n\ ...@@ -381,60 +361,56 @@ When the database has been opened in fast mode, this method forces\n\
any unwritten data to be written to the disk."; any unwritten data to be written to the disk.";
static PyObject * static PyObject *
dbm_sync(dp, args) dbm_sync(register dbmobject *dp, PyObject *args)
register dbmobject *dp;
PyObject *args;
{ {
if (!PyArg_NoArgs(args)) if (!PyArg_ParseTuple(args, ":sync"))
return NULL; return NULL;
check_dbmobject_open(dp); check_dbmobject_open(dp);
gdbm_sync(dp->di_dbm); gdbm_sync(dp->di_dbm);
Py_INCREF(Py_None); Py_INCREF(Py_None);
return Py_None; return Py_None;
} }
static PyMethodDef dbm_methods[] = { static PyMethodDef dbm_methods[] = {
{"close", (PyCFunction)dbm_close, 0, dbm_close__doc__}, {"close", (PyCFunction)dbm_close, METH_VARARGS, dbm_close__doc__},
{"keys", (PyCFunction)dbm_keys, 0, dbm_keys__doc__}, {"keys", (PyCFunction)dbm_keys, METH_VARARGS, dbm_keys__doc__},
{"has_key", (PyCFunction)dbm_has_key, 0, dbm_has_key__doc__}, {"has_key", (PyCFunction)dbm_has_key, METH_VARARGS, dbm_has_key__doc__},
{"firstkey", (PyCFunction)dbm_firstkey, 0, dbm_firstkey__doc__}, {"firstkey", (PyCFunction)dbm_firstkey,METH_VARARGS, dbm_firstkey__doc__},
{"nextkey", (PyCFunction)dbm_nextkey, 0, dbm_nextkey__doc__}, {"nextkey", (PyCFunction)dbm_nextkey, METH_VARARGS, dbm_nextkey__doc__},
{"reorganize", (PyCFunction)dbm_reorganize, 0, dbm_reorganize__doc__}, {"reorganize",(PyCFunction)dbm_reorganize,METH_VARARGS, dbm_reorganize__doc__},
{"sync", (PyCFunction)dbm_sync, 0, dbm_sync__doc__}, {"sync", (PyCFunction)dbm_sync, METH_VARARGS, dbm_sync__doc__},
{NULL, NULL} /* sentinel */ {NULL, NULL} /* sentinel */
}; };
static PyObject * static PyObject *
dbm_getattr(dp, name) dbm_getattr(dbmobject *dp, char *name)
dbmobject *dp;
char *name;
{ {
return Py_FindMethod(dbm_methods, (PyObject *)dp, name); return Py_FindMethod(dbm_methods, (PyObject *)dp, name);
} }
static PyTypeObject Dbmtype = { static PyTypeObject Dbmtype = {
PyObject_HEAD_INIT(0) PyObject_HEAD_INIT(0)
0, 0,
"gdbm", "gdbm",
sizeof(dbmobject), sizeof(dbmobject),
0, 0,
(destructor)dbm_dealloc, /*tp_dealloc*/ (destructor)dbm_dealloc, /*tp_dealloc*/
0, /*tp_print*/ 0, /*tp_print*/
(getattrfunc)dbm_getattr, /*tp_getattr*/ (getattrfunc)dbm_getattr, /*tp_getattr*/
0, /*tp_setattr*/ 0, /*tp_setattr*/
0, /*tp_compare*/ 0, /*tp_compare*/
0, /*tp_repr*/ 0, /*tp_repr*/
0, /*tp_as_number*/ 0, /*tp_as_number*/
0, /*tp_as_sequence*/ 0, /*tp_as_sequence*/
&dbm_as_mapping, /*tp_as_mapping*/ &dbm_as_mapping, /*tp_as_mapping*/
0, /*tp_hash*/ 0, /*tp_hash*/
0, /*tp_call*/ 0, /*tp_call*/
0, /*tp_str*/ 0, /*tp_str*/
0, /*tp_getattro*/ 0, /*tp_getattro*/
0, /*tp_setattro*/ 0, /*tp_setattro*/
0, /*tp_as_buffer*/ 0, /*tp_as_buffer*/
0, /*tp_xxx4*/ 0, /*tp_xxx4*/
gdbm_object__doc__, /*tp_doc*/ gdbm_object__doc__, /*tp_doc*/
}; };
/* ----------------------------------------------------------------- */ /* ----------------------------------------------------------------- */
...@@ -460,55 +436,53 @@ The optional mode argument is the Unix mode of the file, used only\n\ ...@@ -460,55 +436,53 @@ 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. "; when the database has to be created. It defaults to octal 0666. ";
static PyObject * static PyObject *
dbmopen(self, args) dbmopen(PyObject *self, PyObject *args)
PyObject *self;
PyObject *args;
{ {
char *name; char *name;
char *flags = "r "; char *flags = "r ";
int iflags; int iflags;
int mode = 0666; int mode = 0666;
if ( !PyArg_ParseTuple(args, "s|si:open", &name, &flags, &mode) ) if (!PyArg_ParseTuple(args, "s|si:open", &name, &flags, &mode))
return NULL; return NULL;
switch (flags[0]) { switch (flags[0]) {
case 'r': case 'r':
iflags = GDBM_READER; iflags = GDBM_READER;
break; break;
case 'w': case 'w':
iflags = GDBM_WRITER; iflags = GDBM_WRITER;
break; break;
case 'c': case 'c':
iflags = GDBM_WRCREAT; iflags = GDBM_WRCREAT;
break; break;
case 'n': case 'n':
iflags = GDBM_NEWDB; iflags = GDBM_NEWDB;
break; break;
default: default:
PyErr_SetString(DbmError, PyErr_SetString(DbmError,
"Flags should be one of 'r', 'w', 'c' or 'n'"); "Flags should be one of 'r', 'w', 'c' or 'n'");
return NULL; return NULL;
} }
if (flags[1] == 'f') if (flags[1] == 'f')
iflags |= GDBM_FAST; iflags |= GDBM_FAST;
return newdbmobject(name, iflags, mode); return newdbmobject(name, iflags, mode);
} }
static PyMethodDef dbmmodule_methods[] = { static PyMethodDef dbmmodule_methods[] = {
{ "open", (PyCFunction)dbmopen, 1, dbmopen__doc__}, { "open", (PyCFunction)dbmopen, METH_VARARGS, dbmopen__doc__},
{ 0, 0 }, { 0, 0 },
}; };
DL_EXPORT(void) DL_EXPORT(void)
initgdbm() { initgdbm() {
PyObject *m, *d; PyObject *m, *d;
Dbmtype.ob_type = &PyType_Type; Dbmtype.ob_type = &PyType_Type;
m = Py_InitModule4("gdbm", dbmmodule_methods, m = Py_InitModule4("gdbm", dbmmodule_methods,
gdbmmodule__doc__, (PyObject *)NULL, gdbmmodule__doc__, (PyObject *)NULL,
PYTHON_API_VERSION); PYTHON_API_VERSION);
d = PyModule_GetDict(m); d = PyModule_GetDict(m);
DbmError = PyErr_NewException("gdbm.error", NULL, NULL); DbmError = PyErr_NewException("gdbm.error", NULL, NULL);
if (DbmError != NULL) if (DbmError != NULL)
PyDict_SetItemString(d, "error", DbmError); PyDict_SetItemString(d, "error", DbmError);
} }
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment