Initial revision
diff --git a/Modules/dbhashmodule.c b/Modules/dbhashmodule.c
new file mode 100644
index 0000000..324f928
--- /dev/null
+++ b/Modules/dbhashmodule.c
@@ -0,0 +1,369 @@
+/***********************************************************
+Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
+The Netherlands.
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+/* Berkeley DB hash interface.
+ Author: Michael McLay
+ Hacked: Guido van Rossum
+
+ XXX To do:
+ - provide interface to the B-tree and record libraries too
+ - provide a way to access the various hash functions
+ - support more open flags
+ */
+
+#include "allobjects.h"
+#include "modsupport.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <db.h>
+/* Please don't include internal header files of the Berkeley db package
+ (it messes up the info required in the Setup file) */
+
+typedef struct {
+ OB_HEAD
+ DB *di_dbhash;
+ int di_size; /* -1 means recompute */
+} dbhashobject;
+
+staticforward typeobject Dbhashtype;
+
+#define is_dbhashobject(v) ((v)->ob_type == &Dbhashtype)
+
+static object *DbhashError;
+
+static object *
+newdbhashobject(file, flags, mode,
+ bsize, ffactor, nelem, cachesize, hash, lorder)
+ char *file;
+ int flags;
+ int mode;
+ int bsize;
+ int ffactor;
+ int nelem;
+ int cachesize;
+ int hash; /* XXX ignored */
+ int lorder;
+{
+ dbhashobject *dp;
+ HASHINFO info;
+
+ if ((dp = NEWOBJ(dbhashobject, &Dbhashtype)) == NULL)
+ return NULL;
+
+ info.bsize = bsize;
+ info.ffactor = ffactor;
+ info.nelem = nelem;
+ info.cachesize = cachesize;
+ info.hash = NULL; /* XXX should derive from hash argument */
+ info.lorder = lorder;
+
+ if ((dp->di_dbhash = dbopen(file, flags, mode, DB_HASH, &info)) == NULL) {
+ err_errno(DbhashError);
+ DECREF(dp);
+ return NULL;
+ }
+
+ dp->di_size = -1;
+
+ return (object *)dp;
+}
+
+static object *
+dbhash_close(dp)
+ dbhashobject *dp;
+{
+ if (dp->di_dbhash != NULL) {
+ if ((dp->di_dbhash->close)(dp->di_dbhash) != 0) {
+ err_errno(DbhashError);
+ return NULL;
+ }
+ }
+ dp->di_dbhash = NULL;
+ INCREF(None);
+ return None;
+}
+
+static void
+dbhash_dealloc(dp)
+ dbhashobject *dp;
+{
+ if (dp->di_dbhash != NULL) {
+ if ((dp->di_dbhash->close)(dp->di_dbhash) != 0)
+ fprintf(stderr,
+ "Python dbhash: close errno %s in dealloc\n", errno);
+ }
+ DEL(dp);
+}
+
+static int
+dbhash_length(dp)
+ dbhashobject *dp;
+{
+ if (dp->di_size < 0) {
+ DBT krec, drec;
+ int status;
+ int size = 0;
+ for (status = (dp->di_dbhash->seq)(dp->di_dbhash, &krec, &drec,R_FIRST);
+ status == 0;
+ status = (dp->di_dbhash->seq)(dp->di_dbhash, &krec, &drec, R_NEXT))
+ size++;
+ if (status < 0) {
+ err_errno(DbhashError);
+ return -1;
+ }
+ dp->di_size = size;
+ }
+ return dp->di_size;
+}
+
+static object *
+dbhash_subscript(dp, key)
+ dbhashobject *dp;
+ object *key;
+{
+ int status;
+ object *v;
+ DBT krec, drec;
+ char *data;
+ int size;
+
+ if (!getargs(key, "s#", &data, &size))
+ return NULL;
+ krec.data = data;
+ krec.size = size;
+
+ status = (dp->di_dbhash->get)(dp->di_dbhash, &krec, &drec, 0);
+ if (status != 0) {
+ if (status < 0)
+ err_errno(DbhashError);
+ else
+ err_setval(KeyError, key);
+ return NULL;
+ }
+
+ return newsizedstringobject((char *)drec.data, (int)drec.size);
+}
+
+static int
+dbhash_ass_sub(dp, key, value)
+ dbhashobject *dp;
+ object *key, *value;
+{
+ int status;
+ DBT krec, drec;
+ char *data;
+ int size;
+
+ if (!getargs(key, "s#", &data, &size)) {
+ err_setstr(TypeError, "dbhash key type must be string");
+ return -1;
+ }
+ krec.data = data;
+ krec.size = size;
+ dp->di_size = -1;
+ if (value == NULL) {
+ status = (dp->di_dbhash->del)(dp->di_dbhash, &krec, 0);
+ }
+ else {
+ if (!getargs(value, "s#", &data, &size)) {
+ err_setstr(TypeError, "dbhash value type must be string");
+ return -1;
+ }
+ drec.data = data;
+ drec.size = size;
+ status = (dp->di_dbhash->put)(dp->di_dbhash, &krec, &drec, 0);
+ }
+ if (status != 0) {
+ if (status < 0)
+ err_errno(DbhashError);
+ else
+ err_setval(KeyError, key);
+ return -1;
+ }
+ return 0;
+}
+
+static mapping_methods dbhash_as_mapping = {
+ (inquiry)dbhash_length, /*mp_length*/
+ (binaryfunc)dbhash_subscript, /*mp_subscript*/
+ (objobjargproc)dbhash_ass_sub, /*mp_ass_subscript*/
+};
+
+static object *
+dbhash_keys(dp, args)
+ dbhashobject *dp;
+ object *args;
+{
+ object *list, *item;
+ DBT krec, drec;
+ int status;
+ int err;
+
+ if (dp == NULL || !is_dbhashobject(dp)) {
+ err_badcall();
+ return NULL;
+ }
+ if (!getnoarg(args))
+ return NULL;
+ list = newlistobject(0);
+ if (list == NULL)
+ return NULL;
+ for (status = (dp->di_dbhash->seq)(dp->di_dbhash, &krec, &drec, R_FIRST);
+ status == 0;
+ status = (dp->di_dbhash->seq)(dp->di_dbhash, &krec, &drec, R_NEXT)) {
+ item = newsizedstringobject((char *)krec.data, (int)krec.size);
+ if (item == NULL) {
+ DECREF(list);
+ return NULL;
+ }
+ err = addlistitem(list, item);
+ DECREF(item);
+ if (err != 0) {
+ DECREF(list);
+ return NULL;
+ }
+ }
+ if (status < 0) {
+ err_errno(DbhashError);
+ DECREF(list);
+ return NULL;
+ }
+ if (dp->di_size < 0)
+ dp->di_size = getlistsize(list); /* We just did the work for this... */
+ return list;
+}
+
+static object *
+dbhash_has_key(dp, args)
+ dbhashobject *dp;
+ object *args;
+{
+ DBT krec, drec;
+ int status;
+ char *data;
+ int size;
+
+ if (!getargs(args, "s#", &data, &size))
+ return NULL;
+ krec.data = data;
+ krec.size = size;
+
+ status = (dp->di_dbhash->get)(dp->di_dbhash, &krec, &drec, 0);
+ if (status < 0) {
+ err_errno(DbhashError);
+ return NULL;
+ }
+
+ return newintobject(status == 0);
+}
+
+static struct methodlist dbhash_methods[] = {
+ {"close", (method)dbhash_close},
+ {"keys", (method)dbhash_keys},
+ {"has_key", (method)dbhash_has_key},
+ {NULL, NULL} /* sentinel */
+};
+
+static object *
+dbhash_getattr(dp, name)
+ object *dp;
+ char *name;
+{
+ return findmethod(dbhash_methods, dp, name);
+}
+
+static typeobject Dbhashtype = {
+ OB_HEAD_INIT(&Typetype)
+ 0,
+ "dbhash",
+ sizeof(dbhashobject),
+ 0,
+ (destructor)dbhash_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc)dbhash_getattr, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ 0, /*tp_compare*/
+ 0, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ &dbhash_as_mapping, /*tp_as_mapping*/
+};
+
+static object *
+dbhashopen(self, args)
+ object *self;
+ object *args;
+{
+ char *file;
+ char *flag = NULL;
+ int flags = O_RDONLY;
+ int mode = 0666;
+ int bsize = 0;
+ int ffactor = 0;
+ int nelem = 0;
+ int cachesize = 0;
+ int hash = 0; /* XXX currently ignored */
+ int lorder = 0;
+
+ if (!newgetargs(args, "s|siiiiiii",
+ &file, &flag, &mode,
+ &bsize, &ffactor, &nelem, &cachesize, &hash, &lorder))
+ return NULL;
+ if (flag != NULL) {
+ /* XXX need a way to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
+ if (strcmp(flag, "r") == 0)
+ flags = O_RDONLY;
+ else if (strcmp(flag, "w") == 0)
+ flags = O_RDWR;
+ else if (strcmp(flag, "c") == 0)
+ flags = O_RDWR|O_CREAT;
+ else if (strcmp(flag, "n") == 0)
+ flags = O_RDWR|O_CREAT|O_TRUNC;
+ else {
+ err_setstr(DbhashError,
+ "Flag should be one of 'r', 'w', 'c' or 'n'");
+ return NULL;
+ }
+ }
+ return newdbhashobject(file, flags, mode,
+ bsize, ffactor, nelem, cachesize, hash, lorder);
+}
+
+static struct methodlist dbhashmodule_methods[] = {
+ {"open", (method)dbhashopen, 1},
+ {0, 0},
+};
+
+void
+initdbhash() {
+ object *m, *d;
+
+ m = initmodule("dbhash", dbhashmodule_methods);
+ d = getmoduledict(m);
+ DbhashError = newstringobject("dbhash.error");
+ if (DbhashError == NULL || dictinsert(d, "error", DbhashError))
+ fatal("can't define dbhash.error");
+}