diff --git a/Modules/gdbmmodule.c b/Modules/gdbmmodule.c
index e4829ea..de5f94a 100644
--- a/Modules/gdbmmodule.c
+++ b/Modules/gdbmmodule.c
@@ -36,8 +36,7 @@
 /* DBM module using dictionary interface */
 
 
-#include "allobjects.h"
-#include "modsupport.h"
+#include "Python.h"
 
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -45,39 +44,40 @@
 #include "gdbm.h"
 
 typedef struct {
-	OB_HEAD
+	PyObject_HEAD
 	int di_size;	/* -1 means recompute */
 	GDBM_FILE di_dbm;
 } dbmobject;
 
-staticforward typeobject Dbmtype;
+staticforward PyTypeObject Dbmtype;
 
 #define is_dbmobject(v) ((v)->ob_type == &Dbmtype)
 
-static object *DbmError;
+static PyObject *DbmError;
 
-static object *
+static PyObject *
 newdbmobject(file, flags, mode)
-    char *file;
-    int flags;
-    int mode;
+	char *file;
+int flags;
+int mode;
 {
         dbmobject *dp;
 
-	dp = NEWOBJ(dbmobject, &Dbmtype);
+	dp = PyObject_NEW(dbmobject, &Dbmtype);
 	if (dp == NULL)
 		return NULL;
 	dp->di_size = -1;
 	errno = 0;
 	if ( (dp->di_dbm = gdbm_open(file, 0, flags, mode, NULL)) == 0 ) {
-	    if (errno != 0)
-	        err_errno(DbmError);
-	    else
-	        err_setstr(DbmError, (char *) gdbm_strerror(gdbm_errno));
-	    DECREF(dp);
-	    return NULL;
+		if (errno != 0)
+			PyErr_SetFromErrno(DbmError);
+		else
+			PyErr_SetString(DbmError,
+					(char *) gdbm_strerror(gdbm_errno));
+		Py_DECREF(dp);
+		return NULL;
 	}
-	return (object *)dp;
+	return (PyObject *)dp;
 }
 
 /* Methods */
@@ -87,8 +87,8 @@
 	register dbmobject *dp;
 {
         if ( dp->di_dbm )
-	  gdbm_close(dp->di_dbm);
-	DEL(dp);
+		gdbm_close(dp->di_dbm);
+	PyMem_DEL(dp);
 }
 
 static int
@@ -96,39 +96,40 @@
 	dbmobject *dp;
 {
         if ( dp->di_size < 0 ) {
-	    datum key,okey;
-	    int size;
-    	    okey.dsize=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;
-    	    }
-	    dp->di_size = size;
+		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 object *
+static PyObject *
 dbm_subscript(dp, key)
 	dbmobject *dp;
-	register object *key;
+register PyObject *key;
 {
-	object *v;
+	PyObject *v;
 	datum drec, krec;
 	
-	if (!getargs(key, "s#", &krec.dptr, &krec.dsize) )
+	if (!PyArg_Parse(key, "s#", &krec.dptr, &krec.dsize) )
 		return NULL;
 	
 	drec = gdbm_fetch(dp->di_dbm, krec);
 	if ( drec.dptr == 0 ) {
-	    err_setstr(KeyError, GETSTRINGVALUE((stringobject *)key));
-	    return NULL;
+		PyErr_SetString(PyExc_KeyError,
+				PyString_AS_STRING((PyStringObject *)key));
+		return NULL;
 	}
-	v = newsizedstringobject(drec.dptr, drec.dsize);
+	v = PyString_FromStringAndSize(drec.dptr, drec.dsize);
 	free(drec.dptr);
 	return v;
 }
@@ -136,260 +137,264 @@
 static int
 dbm_ass_sub(dp, v, w)
 	dbmobject *dp;
-	object *v, *w;
+PyObject *v, *w;
 {
         datum krec, drec;
 	
-        if ( !getargs(v, "s#", &krec.dptr, &krec.dsize) ) {
-	    err_setstr(TypeError, "gdbm mappings have string indices only");
-	    return -1;
+        if ( !PyArg_Parse(v, "s#", &krec.dptr, &krec.dsize) ) {
+		PyErr_SetString(PyExc_TypeError,
+				"gdbm mappings have string indices only");
+		return -1;
 	}
 	dp->di_size = -1;
 	if (w == NULL) {
-	    if ( gdbm_delete(dp->di_dbm, krec) < 0 ) {
-		err_setstr(KeyError, GETSTRINGVALUE((stringobject *)v));
-		return -1;
-	    }
+		if ( gdbm_delete(dp->di_dbm, krec) < 0 ) {
+			PyErr_SetString(PyExc_KeyError,
+				      PyString_AS_STRING((PyStringObject *)v));
+			return -1;
+		}
 	} else {
-	    if ( !getargs(w, "s#", &drec.dptr, &drec.dsize) ) {
-		err_setstr(TypeError,
-			   "gdbm mappings have string elements only");
-		return -1;
-	    }
-	    errno = 0;
-	    if ( gdbm_store(dp->di_dbm, krec, drec, GDBM_REPLACE) < 0 ) {
-	        if (errno != 0)
-	            err_errno(DbmError);
-	        else
-	            err_setstr(DbmError, (char *) gdbm_strerror(gdbm_errno));
-		return -1;
-	    }
+		if ( !PyArg_Parse(w, "s#", &drec.dptr, &drec.dsize) ) {
+			PyErr_SetString(PyExc_TypeError,
+				    "gdbm mappings have string elements only");
+			return -1;
+		}
+		errno = 0;
+		if ( gdbm_store(dp->di_dbm, krec, drec, GDBM_REPLACE) < 0 ) {
+			if (errno != 0)
+				PyErr_SetFromErrno(DbmError);
+			else
+				PyErr_SetString(DbmError,
+					   (char *) gdbm_strerror(gdbm_errno));
+			return -1;
+		}
 	}
 	return 0;
 }
 
-static mapping_methods dbm_as_mapping = {
+static PyMappingMethods dbm_as_mapping = {
 	(inquiry)dbm_length,		/*mp_length*/
 	(binaryfunc)dbm_subscript,	/*mp_subscript*/
 	(objobjargproc)dbm_ass_sub,	/*mp_ass_subscript*/
 };
 
-static object *
+static PyObject *
 dbm_close(dp, args)
 	register dbmobject *dp;
-	object *args;
+PyObject *args;
 {
-	if ( !getnoarg(args) )
+	if ( !PyArg_NoArgs(args) )
 		return NULL;
         if ( dp->di_dbm )
 		gdbm_close(dp->di_dbm);
 	dp->di_dbm = NULL;
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
-static object *
+static PyObject *
 dbm_keys(dp, args)
 	register dbmobject *dp;
-	object *args;
+PyObject *args;
 {
-	register object *v, *item;
+	register PyObject *v, *item;
 	datum key, nextkey;
 	int err;
 
 	if (dp == NULL || !is_dbmobject(dp)) {
-		err_badcall();
+		PyErr_BadInternalCall();
 		return NULL;
 	}
 
-	if (!getnoarg(args))
+	if (!PyArg_NoArgs(args))
 		return NULL;
 
-	v = newlistobject(0);
+	v = PyList_New(0);
 	if (v == NULL)
 		return NULL;
 
 	key = gdbm_firstkey(dp->di_dbm);
 	while (key.dptr) {
-	    item = newsizedstringobject(key.dptr, key.dsize);
-	    if (item == NULL) {
+		item = PyString_FromStringAndSize(key.dptr, key.dsize);
+		if (item == NULL) {
+			free(key.dptr);
+			Py_DECREF(v);
+			return NULL;
+		}
+		err = PyList_Append(v, item);
+		Py_DECREF(item);
+		if (err != 0) {
+			free(key.dptr);
+			Py_DECREF(v);
+			return NULL;
+		}
+		nextkey = gdbm_nextkey(dp->di_dbm, key);
 		free(key.dptr);
-		DECREF(v);
-		return NULL;
-	    }
-	    err = addlistitem(v, item);
-	    DECREF(item);
-	    if (err != 0) {
-		free(key.dptr);
-		DECREF(v);
-		return NULL;
-	    }
-	    nextkey = gdbm_nextkey(dp->di_dbm, key);
-	    free(key.dptr);
-	    key = nextkey;
+		key = nextkey;
 	}
 
 	return v;
 }
 
-static object *
+static PyObject *
 dbm_has_key(dp, args)
 	register dbmobject *dp;
-	object *args;
+PyObject *args;
 {
 	datum key;
 	
-	if (!getargs(args, "s#", &key.dptr, &key.dsize))
+	if (!PyArg_Parse(args, "s#", &key.dptr, &key.dsize))
 		return NULL;
-	return newintobject((long) gdbm_exists(dp->di_dbm, key));
+	return PyInt_FromLong((long) gdbm_exists(dp->di_dbm, key));
 }
 
-static object *
+static PyObject *
 dbm_firstkey(dp, args)
 	register dbmobject *dp;
-	object *args;
+PyObject *args;
 {
-	register object *v;
+	register PyObject *v;
 	datum key;
 
-	if (!getnoarg(args))
+	if (!PyArg_NoArgs(args))
 		return NULL;
 	key = gdbm_firstkey(dp->di_dbm);
 	if (key.dptr) {
-	    v = newsizedstringobject(key.dptr, key.dsize);
-	    free(key.dptr);
-	    return v;
+		v = PyString_FromStringAndSize(key.dptr, key.dsize);
+		free(key.dptr);
+		return v;
 	} else {
-	    INCREF(None);
-	    return None;
+		Py_INCREF(Py_None);
+		return Py_None;
 	}
 }
 
-static object *
+static PyObject *
 dbm_nextkey(dp, args)
 	register dbmobject *dp;
-	object *args;
+PyObject *args;
 {
-	register object *v;
+	register PyObject *v;
 	datum key, nextkey;
 
-	if (!getargs(args, "s#", &key.dptr, &key.dsize))
+	if (!PyArg_Parse(args, "s#", &key.dptr, &key.dsize))
 		return NULL;
 	nextkey = gdbm_nextkey(dp->di_dbm, key);
 	if (nextkey.dptr) {
-	    v = newsizedstringobject(nextkey.dptr, nextkey.dsize);
-	    free(nextkey.dptr);
-	    return v;
+		v = PyString_FromStringAndSize(nextkey.dptr, nextkey.dsize);
+		free(nextkey.dptr);
+		return v;
 	} else {
-	    INCREF(None);
-	    return None;
+		Py_INCREF(Py_None);
+		return Py_None;
 	}
 }
 
-static object *
+static PyObject *
 dbm_reorganize(dp, args)
 	register dbmobject *dp;
-	object *args;
+PyObject *args;
 {
-	if (!getnoarg(args))
+	if (!PyArg_NoArgs(args))
 		return NULL;
 	errno = 0;
 	if (gdbm_reorganize(dp->di_dbm) < 0) {
-	    if (errno != 0)
-		err_errno(DbmError);
-	    else
-		err_setstr(DbmError, (char *) gdbm_strerror(gdbm_errno));
-	    return NULL;
+		if (errno != 0)
+			PyErr_SetFromErrno(DbmError);
+		else
+			PyErr_SetString(DbmError,
+					(char *) gdbm_strerror(gdbm_errno));
+		return NULL;
 	}
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
-static struct methodlist dbm_methods[] = {
-	{"close",	(method)dbm_close},
-	{"keys",	(method)dbm_keys},
-	{"has_key",	(method)dbm_has_key},
-	{"firstkey",	(method)dbm_firstkey},
-	{"nextkey",	(method)dbm_nextkey},
-	{"reorganize",	(method)dbm_reorganize},
+static PyMethodDef dbm_methods[] = {
+	{"close",	(PyCFunction)dbm_close},
+	{"keys",	(PyCFunction)dbm_keys},
+	{"has_key",	(PyCFunction)dbm_has_key},
+	{"firstkey",	(PyCFunction)dbm_firstkey},
+	{"nextkey",	(PyCFunction)dbm_nextkey},
+	{"reorganize",	(PyCFunction)dbm_reorganize},
 	{NULL,		NULL}		/* sentinel */
 };
 
-static object *
+static PyObject *
 dbm_getattr(dp, name)
 	dbmobject *dp;
-	char *name;
+char *name;
 {
-	return findmethod(dbm_methods, (object *)dp, name);
+	return Py_FindMethod(dbm_methods, (PyObject *)dp, name);
 }
 
-static typeobject Dbmtype = {
-	OB_HEAD_INIT(&Typetype)
+static PyTypeObject Dbmtype = {
+	PyObject_HEAD_INIT(&PyType_Type)
 	0,
 	"gdbm",
 	sizeof(dbmobject),
 	0,
-	(destructor)dbm_dealloc, /*tp_dealloc*/
-	0,			/*tp_print*/
-	(getattrfunc)dbm_getattr, /*tp_getattr*/
-	0,			/*tp_setattr*/
-	0,			/*tp_compare*/
-	0,			/*tp_repr*/
-	0,			/*tp_as_number*/
-	0,			/*tp_as_sequence*/
-	&dbm_as_mapping,	/*tp_as_mapping*/
+	(destructor)dbm_dealloc,   /*tp_dealloc*/
+	0,			   /*tp_print*/
+	(getattrfunc)dbm_getattr,  /*tp_getattr*/
+	0,			   /*tp_setattr*/
+	0,			   /*tp_compare*/
+	0,			   /*tp_repr*/
+	0,			   /*tp_as_number*/
+	0,			   /*tp_as_sequence*/
+	&dbm_as_mapping,	   /*tp_as_mapping*/
 };
 
 /* ----------------------------------------------------------------- */
 
-static object *
+static PyObject *
 dbmopen(self, args)
-    object *self;
-    object *args;
+	PyObject *self;
+PyObject *args;
 {
-    char *name;
-    char *flags = "r ";
-    int iflags;
-   int mode = 0666;
+	char *name;
+	char *flags = "r ";
+	int iflags;
+	int mode = 0666;
 
 /* XXXX add other flags. 2nd character can be "f" meaning open in fast mode. */
-    if ( !newgetargs(args, "s|si", &name, &flags, &mode) )
-	  return NULL;
+	if ( !PyArg_ParseTuple(args, "s|si", &name, &flags, &mode) )
+		return NULL;
 	switch (flags[0]) {
 	case 'r':
-	  iflags = GDBM_READER;
-	  break;
+		iflags = GDBM_READER;
+		break;
 	case 'w':
-	  iflags = GDBM_WRITER;
-	  break;
+		iflags = GDBM_WRITER;
+		break;
 	case 'c':
-	  iflags = GDBM_WRCREAT;
-	  break;
+		iflags = GDBM_WRCREAT;
+		break;
 	case 'n':
-	  iflags = GDBM_NEWDB;
-	  break;
-    default:
-	    err_setstr(DbmError,
-		       "Flags should be one of 'r', 'w', 'c' or 'n'");
-	    return NULL;
+		iflags = GDBM_NEWDB;
+		break;
+	default:
+		PyErr_SetString(DbmError,
+				"Flags should be one of 'r', 'w', 'c' or 'n'");
+		return NULL;
 	}
 	if (flags[1] == 'f')
-	  iflags |= GDBM_FAST;
-    return newdbmobject(name, iflags, mode);
+		iflags |= GDBM_FAST;
+	return newdbmobject(name, iflags, mode);
 }
 
-static struct methodlist dbmmodule_methods[] = {
-    { "open", (method)dbmopen, 1 },
-    { 0, 0 },
+static PyMethodDef dbmmodule_methods[] = {
+	{ "open", (PyCFunction)dbmopen, 1 },
+	{ 0, 0 },
 };
 
 void
 initgdbm() {
-    object *m, *d;
+	PyObject *m, *d;
 
-    m = initmodule("gdbm", dbmmodule_methods);
-    d = getmoduledict(m);
-    DbmError = newstringobject("gdbm.error");
-    if ( DbmError == NULL || dictinsert(d, "error", DbmError) )
-      fatal("can't define gdbm.error");
+	m = Py_InitModule("gdbm", dbmmodule_methods);
+	d = PyModule_GetDict(m);
+	DbmError = PyString_FromString("gdbm.error");
+	if ( DbmError == NULL || PyDict_SetItemString(d, "error", DbmError) )
+		Py_FatalError("can't define gdbm.error");
 }