diff --git a/src/if_py_both.h b/src/if_py_both.h
index fd50033..e60c35d 100644
--- a/src/if_py_both.h
+++ b/src/if_py_both.h
@@ -76,7 +76,7 @@
 } OutputObject;
 
     static int
-OutputSetattr(PyObject *self, char *name, PyObject *val)
+OutputSetattr(OutputObject *self, char *name, PyObject *val)
 {
     if (val == NULL)
     {
@@ -93,7 +93,7 @@
 	    return -1;
 	}
 
-	((OutputObject *)(self))->softspace = PyInt_AsLong(val);
+	self->softspace = PyInt_AsLong(val);
 	return 0;
     }
 
@@ -152,11 +152,11 @@
 }
 
     static PyObject *
-OutputWrite(PyObject *self, PyObject *args)
+OutputWrite(OutputObject *self, PyObject *args)
 {
     Py_ssize_t len = 0;
     char *str = NULL;
-    int error = ((OutputObject *)(self))->error;
+    int error = self->error;
 
     if (!PyArg_ParseTuple(args, "et#", ENC_OPT, &str, &len))
 	return NULL;
@@ -173,12 +173,12 @@
 }
 
     static PyObject *
-OutputWritelines(PyObject *self, PyObject *args)
+OutputWritelines(OutputObject *self, PyObject *args)
 {
     PyInt n;
     PyInt i;
     PyObject *list;
-    int error = ((OutputObject *)(self))->error;
+    int error = self->error;
 
     if (!PyArg_ParseTuple(args, "O", &list))
 	return NULL;
@@ -220,7 +220,7 @@
 }
 
     static PyObject *
-OutputFlush(PyObject *self UNUSED, PyObject *args UNUSED)
+OutputFlush(PyObject *self UNUSED)
 {
     /* do nothing */
     Py_INCREF(Py_None);
@@ -230,11 +230,11 @@
 /***************/
 
 static struct PyMethodDef OutputMethods[] = {
-    /* name,	    function,		calling,    documentation */
-    {"write",	    OutputWrite,	1,	    ""},
-    {"writelines",  OutputWritelines,	1,	    ""},
-    {"flush",	    OutputFlush,	1,	    ""},
-    { NULL,	    NULL,		0,	    NULL}
+    /* name,	    function,				calling,	doc */
+    {"write",	    (PyCFunction)OutputWrite,		METH_VARARGS,	""},
+    {"writelines",  (PyCFunction)OutputWritelines,	METH_VARARGS,	""},
+    {"flush",	    (PyCFunction)OutputFlush,		METH_NOARGS,	""},
+    { NULL,	    NULL,				0,		NULL}
 };
 
 static OutputObject Output =
@@ -533,12 +533,12 @@
  */
 
 static struct PyMethodDef VimMethods[] = {
-    /* name,	     function,		calling,    documentation */
-    {"command",	     VimCommand,	1,	    "Execute a Vim ex-mode command" },
-    {"eval",	     VimEval,		1,	    "Evaluate an expression using Vim evaluator" },
-    {"bindeval",     VimEvalPy,		1,	    "Like eval(), but returns objects attached to vim ones"},
-    {"strwidth",     VimStrwidth,	1,	    "Screen string width, counts <Tab> as having width 1"},
-    { NULL,	     NULL,		0,	    NULL }
+    /* name,	     function,		calling,	documentation */
+    {"command",	     VimCommand,	METH_VARARGS,	"Execute a Vim ex-mode command" },
+    {"eval",	     VimEval,		METH_VARARGS,	"Evaluate an expression using Vim evaluator" },
+    {"bindeval",     VimEvalPy,		METH_VARARGS,	"Like eval(), but returns objects attached to vim ones"},
+    {"strwidth",     VimStrwidth,	METH_VARARGS,	"Screen string width, counts <Tab> as having width 1"},
+    { NULL,	     NULL,		0,		NULL }
 };
 
 /*
@@ -583,22 +583,18 @@
 }
 
     static void
-IterDestructor(PyObject *self)
+IterDestructor(IterObject *self)
 {
-    IterObject *this = (IterObject *)(self);
-
-    this->destruct(this->cur);
+    self->destruct(self->cur);
 
     DESTRUCTOR_FINISH(self);
 }
 
     static int
-IterTraverse(PyObject *self, visitproc visit, void *arg)
+IterTraverse(IterObject *self, visitproc visit, void *arg)
 {
-    IterObject *this = (IterObject *)(self);
-
-    if (this->traverse != NULL)
-	return this->traverse(this->cur, visit, arg);
+    if (self->traverse != NULL)
+	return self->traverse(self->cur, visit, arg);
     else
 	return 0;
 }
@@ -609,22 +605,18 @@
 #endif
 
     static int
-IterClear(PyObject *self)
+IterClear(IterObject *self)
 {
-    IterObject *this = (IterObject *)(self);
-
-    if (this->clear != NULL)
-	return this->clear(&this->cur);
+    if (self->clear != NULL)
+	return self->clear(&self->cur);
     else
 	return 0;
 }
 
     static PyObject *
-IterNext(PyObject *self)
+IterNext(IterObject *self)
 {
-    IterObject *this = (IterObject *)(self);
-
-    return this->next(&this->cur);
+    return self->next(&self->cur);
 }
 
     static PyObject *
@@ -711,21 +703,17 @@
 }
 
     static void
-DictionaryDestructor(PyObject *self)
+DictionaryDestructor(DictionaryObject *self)
 {
-    DictionaryObject	*this = ((DictionaryObject *) (self));
-
-    pyll_remove(&this->ref, &lastdict);
-    dict_unref(this->dict);
+    pyll_remove(&self->ref, &lastdict);
+    dict_unref(self->dict);
 
     DESTRUCTOR_FINISH(self);
 }
 
     static int
-DictionarySetattr(PyObject *self, char *name, PyObject *val)
+DictionarySetattr(DictionaryObject *self, char *name, PyObject *val)
 {
-    DictionaryObject *this = (DictionaryObject *)(self);
-
     if (val == NULL)
     {
 	PyErr_SetString(PyExc_AttributeError, _("Cannot delete DictionaryObject attributes"));
@@ -734,7 +722,7 @@
 
     if (strcmp(name, "locked") == 0)
     {
-	if (this->dict->dv_lock == VAR_FIXED)
+	if (self->dict->dv_lock == VAR_FIXED)
 	{
 	    PyErr_SetString(PyExc_TypeError, _("Cannot modify fixed dictionary"));
 	    return -1;
@@ -745,9 +733,9 @@
 	    if (istrue == -1)
 		return -1;
 	    else if (istrue)
-		this->dict->dv_lock = VAR_LOCKED;
+		self->dict->dv_lock = VAR_LOCKED;
 	    else
-		this->dict->dv_lock = 0;
+		self->dict->dv_lock = 0;
 	}
 	return 0;
     }
@@ -759,13 +747,13 @@
 }
 
     static PyInt
-DictionaryLength(PyObject *self)
+DictionaryLength(DictionaryObject *self)
 {
-    return ((PyInt) ((((DictionaryObject *)(self))->dict->dv_hashtab.ht_used)));
+    return ((PyInt) (self->dict->dv_hashtab.ht_used));
 }
 
     static PyObject *
-DictionaryItem(PyObject *self, PyObject *keyObject)
+DictionaryItem(DictionaryObject *self, PyObject *keyObject)
 {
     char_u	*key;
     dictitem_T	*di;
@@ -773,7 +761,7 @@
 
     DICTKEY_GET_NOTEMPTY(NULL)
 
-    di = dict_find(((DictionaryObject *) (self))->dict, key, -1);
+    di = dict_find(self->dict, key, -1);
 
     DICTKEY_UNREF
 
@@ -787,11 +775,11 @@
 }
 
     static PyInt
-DictionaryAssItem(PyObject *self, PyObject *keyObject, PyObject *valObject)
+DictionaryAssItem(DictionaryObject *self, PyObject *keyObject, PyObject *valObject)
 {
     char_u	*key;
     typval_T	tv;
-    dict_T	*d = ((DictionaryObject *)(self))->dict;
+    dict_T	*d = self->dict;
     dictitem_T	*di;
     DICTKEY_DECL
 
@@ -852,9 +840,9 @@
 }
 
     static PyObject *
-DictionaryListKeys(PyObject *self UNUSED)
+DictionaryListKeys(DictionaryObject *self)
 {
-    dict_T	*dict = ((DictionaryObject *)(self))->dict;
+    dict_T	*dict = self->dict;
     long_u	todo = dict->dv_hashtab.ht_used;
     Py_ssize_t	i = 0;
     PyObject	*r;
@@ -880,8 +868,8 @@
 };
 
 static struct PyMethodDef DictionaryMethods[] = {
-    {"keys", (PyCFunction)DictionaryListKeys, METH_NOARGS, ""},
-    { NULL,	    NULL,		0,	    NULL }
+    {"keys",	(PyCFunction)DictionaryListKeys,	METH_NOARGS,	""},
+    { NULL,	NULL,					0,		NULL }
 };
 
 static PyTypeObject ListType;
@@ -912,12 +900,10 @@
 }
 
     static void
-ListDestructor(PyObject *self)
+ListDestructor(ListObject *self)
 {
-    ListObject *this = (ListObject *)(self);
-
-    pyll_remove(&this->ref, &lastlist);
-    list_unref(this->list);
+    pyll_remove(&self->ref, &lastlist);
+    list_unref(self->list);
 
     DESTRUCTOR_FINISH(self);
 }
@@ -952,22 +938,22 @@
 }
 
     static PyInt
-ListLength(PyObject *self)
+ListLength(ListObject *self)
 {
-    return ((PyInt) (((ListObject *) (self))->list->lv_len));
+    return ((PyInt) (self->list->lv_len));
 }
 
     static PyObject *
-ListItem(PyObject *self, Py_ssize_t index)
+ListItem(ListObject *self, Py_ssize_t index)
 {
     listitem_T	*li;
 
-    if (index>=ListLength(self))
+    if (index >= ListLength(self))
     {
 	PyErr_SetString(PyExc_IndexError, _("list index out of range"));
 	return NULL;
     }
-    li = list_find(((ListObject *) (self))->list, (long) index);
+    li = list_find(self->list, (long) index);
     if (li == NULL)
     {
 	PyErr_SetVim(_("internal error: failed to get vim list item"));
@@ -991,7 +977,7 @@
 	last = size;
 
     static PyObject *
-ListSlice(PyObject *self, Py_ssize_t first, Py_ssize_t last)
+ListSlice(ListObject *self, Py_ssize_t first, Py_ssize_t last)
 {
     PyInt	i;
     PyInt	size = ListLength(self);
@@ -1058,10 +1044,10 @@
 }
 
     static PyObject *
-ListIter(PyObject *self)
+ListIter(ListObject *self)
 {
     listiterinfo_T	*lii;
-    list_T	*l = ((ListObject *) (self))->list;
+    list_T	*l = self->list;
 
     if (!(lii = PyMem_New(listiterinfo_T, 1)))
     {
@@ -1079,10 +1065,10 @@
 }
 
     static int
-ListAssItem(PyObject *self, Py_ssize_t index, PyObject *obj)
+ListAssItem(ListObject *self, Py_ssize_t index, PyObject *obj)
 {
     typval_T	tv;
-    list_T	*l = ((ListObject *) (self))->list;
+    list_T	*l = self->list;
     listitem_T	*li;
     Py_ssize_t	length = ListLength(self);
 
@@ -1127,7 +1113,7 @@
 }
 
     static int
-ListAssSlice(PyObject *self, Py_ssize_t first, Py_ssize_t last, PyObject *obj)
+ListAssSlice(ListObject *self, Py_ssize_t first, Py_ssize_t last, PyObject *obj)
 {
     PyInt	size = ListLength(self);
     Py_ssize_t	i;
@@ -1136,7 +1122,7 @@
     listitem_T	*li;
     listitem_T	*next;
     typval_T	v;
-    list_T	*l = ((ListObject *) (self))->list;
+    list_T	*l = self->list;
 
     if (l->lv_lock)
     {
@@ -1196,9 +1182,9 @@
 }
 
     static PyObject *
-ListConcatInPlace(PyObject *self, PyObject *obj)
+ListConcatInPlace(ListObject *self, PyObject *obj)
 {
-    list_T	*l = ((ListObject *) (self))->list;
+    list_T	*l = self->list;
     PyObject	*lookup_dict;
 
     if (l->lv_lock)
@@ -1222,14 +1208,12 @@
     Py_DECREF(lookup_dict);
 
     Py_INCREF(self);
-    return self;
+    return (PyObject *)(self);
 }
 
     static int
-ListSetattr(PyObject *self, char *name, PyObject *val)
+ListSetattr(ListObject *self, char *name, PyObject *val)
 {
-    ListObject *this = (ListObject *)(self);
-
     if (val == NULL)
     {
 	PyErr_SetString(PyExc_AttributeError,
@@ -1239,7 +1223,7 @@
 
     if (strcmp(name, "locked") == 0)
     {
-	if (this->list->lv_lock == VAR_FIXED)
+	if (self->list->lv_lock == VAR_FIXED)
 	{
 	    PyErr_SetString(PyExc_TypeError, _("cannot modify fixed list"));
 	    return -1;
@@ -1250,9 +1234,9 @@
 	    if (istrue == -1)
 		return -1;
 	    else if (istrue)
-		this->list->lv_lock = VAR_LOCKED;
+		self->list->lv_lock = VAR_LOCKED;
 	    else
-		this->list->lv_lock = 0;
+		self->list->lv_lock = 0;
 	}
 	return 0;
     }
@@ -1264,8 +1248,8 @@
 }
 
 static struct PyMethodDef ListMethods[] = {
-    {"extend", (PyCFunction)ListConcatInPlace, METH_O, ""},
-    { NULL,	    NULL,		0,	    NULL }
+    {"extend",	(PyCFunction)ListConcatInPlace,	METH_O,	""},
+    { NULL,	NULL,				0,	NULL }
 };
 
 typedef struct
@@ -1296,21 +1280,18 @@
 }
 
     static void
-FunctionDestructor(PyObject *self)
+FunctionDestructor(FunctionObject *self)
 {
-    FunctionObject	*this = (FunctionObject *) (self);
-
-    func_unref(this->name);
-    PyMem_Free(this->name);
+    func_unref(self->name);
+    PyMem_Free(self->name);
 
     DESTRUCTOR_FINISH(self);
 }
 
     static PyObject *
-FunctionCall(PyObject *self, PyObject *argsObject, PyObject *kwargs)
+FunctionCall(FunctionObject *self, PyObject *argsObject, PyObject *kwargs)
 {
-    FunctionObject	*this = (FunctionObject *)(self);
-    char_u	*name = this->name;
+    char_u	*name = self->name;
     typval_T	args;
     typval_T	selfdicttv;
     typval_T	rettv;
@@ -1368,8 +1349,8 @@
 }
 
 static struct PyMethodDef FunctionMethods[] = {
-    {"__call__",    (PyCFunction)FunctionCall, METH_VARARGS|METH_KEYWORDS, ""},
-    { NULL,	    NULL,		0,	    NULL }
+    {"__call__",    (PyCFunction)FunctionCall,	METH_VARARGS|METH_KEYWORDS, ""},
+    { NULL,	    NULL,			0,			   NULL}
 };
 
 /*
@@ -1415,29 +1396,29 @@
 }
 
     static void
-OptionsDestructor(PyObject *self)
+OptionsDestructor(OptionsObject *self)
 {
-    if (((OptionsObject *)(self))->fromObj)
-	Py_DECREF(((OptionsObject *)(self))->fromObj);
+    if (self->fromObj)
+	Py_DECREF(self->fromObj);
     DESTRUCTOR_FINISH(self);
 }
 
     static int
-OptionsTraverse(PyObject *self, visitproc visit, void *arg)
+OptionsTraverse(OptionsObject *self, visitproc visit, void *arg)
 {
-    Py_VISIT(((OptionsObject *)(self))->fromObj);
+    Py_VISIT(self->fromObj);
     return 0;
 }
 
     static int
-OptionsClear(PyObject *self)
+OptionsClear(OptionsObject *self)
 {
-    Py_CLEAR(((OptionsObject *)(self))->fromObj);
+    Py_CLEAR(self->fromObj);
     return 0;
 }
 
     static PyObject *
-OptionsItem(OptionsObject *this, PyObject *keyObject)
+OptionsItem(OptionsObject *self, PyObject *keyObject)
 {
     char_u	*key;
     int		flags;
@@ -1445,13 +1426,13 @@
     char_u	*stringval;
     DICTKEY_DECL
 
-    if (this->Check(this->from))
+    if (self->Check(self->from))
 	return NULL;
 
     DICTKEY_GET_NOTEMPTY(NULL)
 
     flags = get_option_value_strict(key, &numval, &stringval,
-				    this->opt_type, this->from);
+				    self->opt_type, self->from);
 
     DICTKEY_UNREF
 
@@ -1532,7 +1513,7 @@
 }
 
     static int
-OptionsAssItem(OptionsObject *this, PyObject *keyObject, PyObject *valObject)
+OptionsAssItem(OptionsObject *self, PyObject *keyObject, PyObject *valObject)
 {
     char_u	*key;
     int		flags;
@@ -1540,13 +1521,13 @@
     int		r = 0;
     DICTKEY_DECL
 
-    if (this->Check(this->from))
+    if (self->Check(self->from))
 	return -1;
 
     DICTKEY_GET_NOTEMPTY(-1)
 
     flags = get_option_value_strict(key, NULL, NULL,
-				    this->opt_type, this->from);
+				    self->opt_type, self->from);
 
     DICTKEY_UNREF
 
@@ -1558,7 +1539,7 @@
 
     if (valObject == NULL)
     {
-	if (this->opt_type == SREQ_GLOBAL)
+	if (self->opt_type == SREQ_GLOBAL)
 	{
 	    PyErr_SetString(PyExc_ValueError,
 		    _("unable to unset global option"));
@@ -1572,12 +1553,12 @@
 	}
 	else
 	{
-	    unset_global_local_option(key, this->from);
+	    unset_global_local_option(key, self->from);
 	    return 0;
 	}
     }
 
-    opt_flags = (this->opt_type ? OPT_LOCAL : OPT_GLOBAL);
+    opt_flags = (self->opt_type ? OPT_LOCAL : OPT_GLOBAL);
 
     if (flags & SOPT_BOOL)
     {
@@ -1585,7 +1566,7 @@
 	if (istrue == -1)
 	    return -1;
 	r = set_option_value_for(key, istrue, NULL,
-				opt_flags, this->opt_type, this->from);
+				opt_flags, self->opt_type, self->from);
     }
     else if (flags & SOPT_NUM)
     {
@@ -1605,7 +1586,7 @@
 	}
 
 	r = set_option_value_for(key, val, NULL, opt_flags,
-				this->opt_type, this->from);
+				self->opt_type, self->from);
     }
     else
     {
@@ -1643,7 +1624,7 @@
 	}
 
 	r = set_option_value_for(key, 0, val, opt_flags,
-				this->opt_type, this->from);
+				self->opt_type, self->from);
 	vim_free(val);
     }
 
@@ -1670,9 +1651,9 @@
 static PyTypeObject TabPageType;
 
     static int
-CheckTabPage(TabPageObject *this)
+CheckTabPage(TabPageObject *self)
 {
-    if (this->tab == INVALID_TABPAGE_VALUE)
+    if (self->tab == INVALID_TABPAGE_VALUE)
     {
 	PyErr_SetVim(_("attempt to refer to deleted tab page"));
 	return -1;
@@ -1704,51 +1685,48 @@
 }
 
     static void
-TabPageDestructor(PyObject *self)
+TabPageDestructor(TabPageObject *self)
 {
-    TabPageObject *this = (TabPageObject *)(self);
-
-    if (this->tab && this->tab != INVALID_TABPAGE_VALUE)
-	TAB_PYTHON_REF(this->tab) = NULL;
+    if (self->tab && self->tab != INVALID_TABPAGE_VALUE)
+	TAB_PYTHON_REF(self->tab) = NULL;
 
     DESTRUCTOR_FINISH(self);
 }
 
     static PyObject *
-TabPageAttr(TabPageObject *this, char *name)
+TabPageAttr(TabPageObject *self, char *name)
 {
     if (strcmp(name, "windows") == 0)
-	return WinListNew(this);
+	return WinListNew(self);
     else if (strcmp(name, "number") == 0)
-	return PyLong_FromLong((long) get_tab_number(this->tab));
+	return PyLong_FromLong((long) get_tab_number(self->tab));
     else if (strcmp(name, "vars") == 0)
-	return DictionaryNew(this->tab->tp_vars);
+	return DictionaryNew(self->tab->tp_vars);
     else if (strcmp(name, "window") == 0)
     {
 	/* For current tab window.c does not bother to set or update tp_curwin
 	 */
-	if (this->tab == curtab)
+	if (self->tab == curtab)
 	    return WindowNew(curwin, curtab);
 	else
-	    return WindowNew(this->tab->tp_curwin, this->tab);
+	    return WindowNew(self->tab->tp_curwin, self->tab);
     }
     return NULL;
 }
 
     static PyObject *
-TabPageRepr(PyObject *self)
+TabPageRepr(TabPageObject *self)
 {
     static char repr[100];
-    TabPageObject *this = (TabPageObject *)(self);
 
-    if (this->tab == INVALID_TABPAGE_VALUE)
+    if (self->tab == INVALID_TABPAGE_VALUE)
     {
 	vim_snprintf(repr, 100, _("<tabpage object (deleted) at %p>"), (self));
 	return PyString_FromString(repr);
     }
     else
     {
-	int	t = get_tab_number(this->tab);
+	int	t = get_tab_number(self->tab);
 
 	if (t == 0)
 	    vim_snprintf(repr, 100, _("<tabpage object (unknown) at %p>"),
@@ -1818,9 +1796,9 @@
 static PyTypeObject WindowType;
 
     static int
-CheckWindow(WindowObject *this)
+CheckWindow(WindowObject *self)
 {
-    if (this->win == INVALID_WINDOW_VALUE)
+    if (self->win == INVALID_WINDOW_VALUE)
     {
 	PyErr_SetVim(_("attempt to refer to deleted window"));
 	return -1;
@@ -1869,14 +1847,12 @@
 }
 
     static void
-WindowDestructor(PyObject *self)
+WindowDestructor(WindowObject *self)
 {
-    WindowObject *this = (WindowObject *)(self);
+    if (self->win && self->win != INVALID_WINDOW_VALUE)
+	WIN_PYTHON_REF(self->win) = NULL;
 
-    if (this->win && this->win != INVALID_WINDOW_VALUE)
-	WIN_PYTHON_REF(this->win) = NULL;
-
-    Py_DECREF(((PyObject *)(this->tabObject)));
+    Py_DECREF(((PyObject *)(self->tabObject)));
 
     DESTRUCTOR_FINISH(self);
 }
@@ -1899,58 +1875,58 @@
 	return firstwin;
 }
     static int
-WindowTraverse(PyObject *self, visitproc visit, void *arg)
+WindowTraverse(WindowObject *self, visitproc visit, void *arg)
 {
-    Py_VISIT(((PyObject *)(((WindowObject *)(self))->tabObject)));
+    Py_VISIT(((PyObject *)(self->tabObject)));
     return 0;
 }
 
     static int
-WindowClear(PyObject *self)
+WindowClear(WindowObject *self)
 {
-    Py_CLEAR((((WindowObject *)(self))->tabObject));
+    Py_CLEAR(self->tabObject);
     return 0;
 }
 
     static PyObject *
-WindowAttr(WindowObject *this, char *name)
+WindowAttr(WindowObject *self, char *name)
 {
     if (strcmp(name, "buffer") == 0)
-	return (PyObject *)BufferNew(this->win->w_buffer);
+	return (PyObject *)BufferNew(self->win->w_buffer);
     else if (strcmp(name, "cursor") == 0)
     {
-	pos_T *pos = &this->win->w_cursor;
+	pos_T *pos = &self->win->w_cursor;
 
 	return Py_BuildValue("(ll)", (long)(pos->lnum), (long)(pos->col));
     }
     else if (strcmp(name, "height") == 0)
-	return PyLong_FromLong((long)(this->win->w_height));
+	return PyLong_FromLong((long)(self->win->w_height));
 #ifdef FEAT_WINDOWS
     else if (strcmp(name, "row") == 0)
-	return PyLong_FromLong((long)(this->win->w_winrow));
+	return PyLong_FromLong((long)(self->win->w_winrow));
 #endif
 #ifdef FEAT_VERTSPLIT
     else if (strcmp(name, "width") == 0)
-	return PyLong_FromLong((long)(W_WIDTH(this->win)));
+	return PyLong_FromLong((long)(W_WIDTH(self->win)));
     else if (strcmp(name, "col") == 0)
-	return PyLong_FromLong((long)(W_WINCOL(this->win)));
+	return PyLong_FromLong((long)(W_WINCOL(self->win)));
 #endif
     else if (strcmp(name, "vars") == 0)
-	return DictionaryNew(this->win->w_vars);
+	return DictionaryNew(self->win->w_vars);
     else if (strcmp(name, "options") == 0)
-	return OptionsNew(SREQ_WIN, this->win, (checkfun) CheckWindow,
-			(PyObject *) this);
+	return OptionsNew(SREQ_WIN, self->win, (checkfun) CheckWindow,
+			(PyObject *) self);
     else if (strcmp(name, "number") == 0)
     {
-	if (CheckTabPage(this->tabObject))
+	if (CheckTabPage(self->tabObject))
 	    return NULL;
 	return PyLong_FromLong((long)
-		get_win_number(this->win, get_firstwin(this->tabObject)));
+		get_win_number(self->win, get_firstwin(self->tabObject)));
     }
     else if (strcmp(name, "tabpage") == 0)
     {
-	Py_INCREF(this->tabObject);
-	return (PyObject *)(this->tabObject);
+	Py_INCREF(self->tabObject);
+	return (PyObject *)(self->tabObject);
     }
     else if (strcmp(name,"__members__") == 0)
 	return Py_BuildValue("[sssssssss]", "buffer", "cursor", "height",
@@ -1960,11 +1936,9 @@
 }
 
     static int
-WindowSetattr(PyObject *self, char *name, PyObject *val)
+WindowSetattr(WindowObject *self, char *name, PyObject *val)
 {
-    WindowObject *this = (WindowObject *)(self);
-
-    if (CheckWindow(this))
+    if (CheckWindow(self))
 	return -1;
 
     if (strcmp(name, "buffer") == 0)
@@ -1980,7 +1954,7 @@
 	if (!PyArg_Parse(val, "(ll)", &lnum, &col))
 	    return -1;
 
-	if (lnum <= 0 || lnum > this->win->w_buffer->b_ml.ml_line_count)
+	if (lnum <= 0 || lnum > self->win->w_buffer->b_ml.ml_line_count)
 	{
 	    PyErr_SetVim(_("cursor position outside buffer"));
 	    return -1;
@@ -1990,13 +1964,13 @@
 	if (VimErrorCheck())
 	    return -1;
 
-	this->win->w_cursor.lnum = lnum;
-	this->win->w_cursor.col = col;
+	self->win->w_cursor.lnum = lnum;
+	self->win->w_cursor.col = col;
 #ifdef FEAT_VIRTUALEDIT
-	this->win->w_cursor.coladd = 0;
+	self->win->w_cursor.coladd = 0;
 #endif
 	/* When column is out of range silently correct it. */
-	check_cursor_col_win(this->win);
+	check_cursor_col_win(self->win);
 
 	update_screen(VALID);
 	return 0;
@@ -2013,7 +1987,7 @@
 	need_mouse_correct = TRUE;
 #endif
 	savewin = curwin;
-	curwin = this->win;
+	curwin = self->win;
 	win_setheight(height);
 	curwin = savewin;
 
@@ -2036,7 +2010,7 @@
 	need_mouse_correct = TRUE;
 #endif
 	savewin = curwin;
-	curwin = this->win;
+	curwin = self->win;
 	win_setwidth(width);
 	curwin = savewin;
 
@@ -2055,19 +2029,18 @@
 }
 
     static PyObject *
-WindowRepr(PyObject *self)
+WindowRepr(WindowObject *self)
 {
     static char repr[100];
-    WindowObject *this = (WindowObject *)(self);
 
-    if (this->win == INVALID_WINDOW_VALUE)
+    if (self->win == INVALID_WINDOW_VALUE)
     {
 	vim_snprintf(repr, 100, _("<window object (deleted) at %p>"), (self));
 	return PyString_FromString(repr);
     }
     else
     {
-	int	w = get_win_number(this->win, firstwin);
+	int	w = get_win_number(self->win, firstwin);
 
 	if (w == 0)
 	    vim_snprintf(repr, 100, _("<window object (unknown) at %p>"),
@@ -2110,9 +2083,9 @@
 }
 
     static void
-WinListDestructor(PyObject *self)
+WinListDestructor(WinListObject *self)
 {
-    TabPageObject	*tabObject = ((WinListObject *)(self))->tabObject;
+    TabPageObject	*tabObject = self->tabObject;
 
     if (tabObject)
 	Py_DECREF((PyObject *)(tabObject));
@@ -2121,12 +2094,12 @@
 }
 
     static PyInt
-WinListLength(PyObject *self)
+WinListLength(WinListObject *self)
 {
     win_T	*w;
     PyInt	n = 0;
 
-    if (!(w = get_firstwin(((WinListObject *)(self))->tabObject)))
+    if (!(w = get_firstwin(self->tabObject)))
 	return -1;
 
     while (w != NULL)
@@ -2139,17 +2112,16 @@
 }
 
     static PyObject *
-WinListItem(PyObject *self, PyInt n)
+WinListItem(WinListObject *self, PyInt n)
 {
-    WinListObject	*this = ((WinListObject *)(self));
     win_T *w;
 
-    if (!(w = get_firstwin(this->tabObject)))
+    if (!(w = get_firstwin(self->tabObject)))
 	return NULL;
 
     for (; w != NULL; w = W_NEXT(w), --n)
 	if (n == 0)
-	    return WindowNew(w, this->tabObject? this->tabObject->tab: curtab);
+	    return WindowNew(w, self->tabObject? self->tabObject->tab: curtab);
 
     PyErr_SetString(PyExc_IndexError, _("no such window"));
     return NULL;
@@ -2721,9 +2693,9 @@
 } BufferObject;
 
     static int
-CheckBuffer(BufferObject *this)
+CheckBuffer(BufferObject *self)
 {
-    if (this->buf == INVALID_BUFFER_VALUE)
+    if (self->buf == INVALID_BUFFER_VALUE)
     {
 	PyErr_SetVim(_("attempt to refer to deleted buffer"));
 	return -1;
@@ -2922,54 +2894,46 @@
 }
 
     static void
-RangeDestructor(PyObject *self)
+RangeDestructor(RangeObject *self)
 {
-    Py_DECREF(((RangeObject *)(self))->buf);
+    Py_DECREF(self->buf);
     DESTRUCTOR_FINISH(self);
 }
 
     static PyInt
-RangeLength(PyObject *self)
+RangeLength(RangeObject *self)
 {
     /* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */
-    if (CheckBuffer(((RangeObject *)(self))->buf))
+    if (CheckBuffer(self->buf))
 	return -1; /* ??? */
 
-    return (((RangeObject *)(self))->end - ((RangeObject *)(self))->start + 1);
+    return (self->end - self->start + 1);
 }
 
     static PyObject *
-RangeItem(PyObject *self, PyInt n)
+RangeItem(RangeObject *self, PyInt n)
 {
-    return RBItem(((RangeObject *)(self))->buf, n,
-		  ((RangeObject *)(self))->start,
-		  ((RangeObject *)(self))->end);
+    return RBItem(self->buf, n, self->start, self->end);
 }
 
     static PyObject *
-RangeSlice(PyObject *self, PyInt lo, PyInt hi)
+RangeSlice(RangeObject *self, PyInt lo, PyInt hi)
 {
-    return RBSlice(((RangeObject *)(self))->buf, lo, hi,
-		   ((RangeObject *)(self))->start,
-		   ((RangeObject *)(self))->end);
+    return RBSlice(self->buf, lo, hi, self->start, self->end);
 }
 
     static PyObject *
-RangeAppend(PyObject *self, PyObject *args)
+RangeAppend(RangeObject *self, PyObject *args)
 {
-    return RBAppend(((RangeObject *)(self))->buf, args,
-		    ((RangeObject *)(self))->start,
-		    ((RangeObject *)(self))->end,
-		    &((RangeObject *)(self))->end);
+    return RBAppend(self->buf, args, self->start, self->end, &self->end);
 }
 
     static PyObject *
-RangeRepr(PyObject *self)
+RangeRepr(RangeObject *self)
 {
     static char repr[100];
-    RangeObject *this = (RangeObject *)(self);
 
-    if (this->buf->buf == INVALID_BUFFER_VALUE)
+    if (self->buf->buf == INVALID_BUFFER_VALUE)
     {
 	vim_snprintf(repr, 100, "<range object (for deleted buffer) at %p>",
 								      (self));
@@ -2977,7 +2941,7 @@
     }
     else
     {
-	char *name = (char *)this->buf->buf->b_fname;
+	char *name = (char *)self->buf->buf->b_fname;
 	int len;
 
 	if (name == NULL)
@@ -2989,16 +2953,16 @@
 
 	vim_snprintf(repr, 100, "<range %s%s (%d:%d)>",
 		len > 45 ? "..." : "", name,
-		this->start, this->end);
+		self->start, self->end);
 
 	return PyString_FromString(repr);
     }
 }
 
 static struct PyMethodDef RangeMethods[] = {
-    /* name,	    function,		calling,    documentation */
-    {"append",	    RangeAppend,	1,	    "Append data to the Vim range" },
-    { NULL,	    NULL,		0,	    NULL }
+    /* name,	function,			calling,	documentation */
+    {"append",	(PyCFunction)RangeAppend,	METH_VARARGS,	"Append data to the Vim range" },
+    { NULL,	NULL,				0,		NULL }
 };
 
 static PyTypeObject BufferType;
@@ -3045,50 +3009,48 @@
 }
 
     static void
-BufferDestructor(PyObject *self)
+BufferDestructor(BufferObject *self)
 {
-    BufferObject *this = (BufferObject *)(self);
-
-    if (this->buf && this->buf != INVALID_BUFFER_VALUE)
-	BUF_PYTHON_REF(this->buf) = NULL;
+    if (self->buf && self->buf != INVALID_BUFFER_VALUE)
+	BUF_PYTHON_REF(self->buf) = NULL;
 
     DESTRUCTOR_FINISH(self);
 }
 
     static PyInt
-BufferLength(PyObject *self)
+BufferLength(BufferObject *self)
 {
     /* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */
-    if (CheckBuffer((BufferObject *)(self)))
+    if (CheckBuffer(self))
 	return -1; /* ??? */
 
-    return (PyInt)(((BufferObject *)(self))->buf->b_ml.ml_line_count);
+    return (PyInt)(self->buf->b_ml.ml_line_count);
 }
 
     static PyObject *
-BufferItem(PyObject *self, PyInt n)
+BufferItem(BufferObject *self, PyInt n)
 {
-    return RBItem((BufferObject *)(self), n, 1, -1);
+    return RBItem(self, n, 1, -1);
 }
 
     static PyObject *
-BufferSlice(PyObject *self, PyInt lo, PyInt hi)
+BufferSlice(BufferObject *self, PyInt lo, PyInt hi)
 {
-    return RBSlice((BufferObject *)(self), lo, hi, 1, -1);
+    return RBSlice(self, lo, hi, 1, -1);
 }
 
     static PyObject *
-BufferAttr(BufferObject *this, char *name)
+BufferAttr(BufferObject *self, char *name)
 {
     if (strcmp(name, "name") == 0)
-	return Py_BuildValue("s", this->buf->b_ffname);
+	return Py_BuildValue("s", self->buf->b_ffname);
     else if (strcmp(name, "number") == 0)
-	return Py_BuildValue(Py_ssize_t_fmt, this->buf->b_fnum);
+	return Py_BuildValue(Py_ssize_t_fmt, self->buf->b_fnum);
     else if (strcmp(name, "vars") == 0)
-	return DictionaryNew(this->buf->b_vars);
+	return DictionaryNew(self->buf->b_vars);
     else if (strcmp(name, "options") == 0)
-	return OptionsNew(SREQ_BUF, this->buf, (checkfun) CheckBuffer,
-			(PyObject *) this);
+	return OptionsNew(SREQ_BUF, self->buf, (checkfun) CheckBuffer,
+			(PyObject *) self);
     else if (strcmp(name,"__members__") == 0)
 	return Py_BuildValue("[ssss]", "name", "number", "vars", "options");
     else
@@ -3096,27 +3058,27 @@
 }
 
     static PyObject *
-BufferAppend(PyObject *self, PyObject *args)
+BufferAppend(BufferObject *self, PyObject *args)
 {
-    return RBAppend((BufferObject *)(self), args, 1, -1, NULL);
+    return RBAppend(self, args, 1, -1, NULL);
 }
 
     static PyObject *
-BufferMark(PyObject *self, PyObject *args)
+BufferMark(BufferObject *self, PyObject *args)
 {
     pos_T	*posp;
     char	*pmark;
     char	mark;
     buf_T	*savebuf;
 
-    if (CheckBuffer((BufferObject *)(self)))
+    if (CheckBuffer(self))
 	return NULL;
 
     if (!PyArg_ParseTuple(args, "s", &pmark))
 	return NULL;
     mark = *pmark;
 
-    switch_buffer(&savebuf, ((BufferObject *)(self))->buf);
+    switch_buffer(&savebuf, self->buf);
     posp = getmark(mark, FALSE);
     restore_buffer(savebuf);
 
@@ -3141,34 +3103,33 @@
 }
 
     static PyObject *
-BufferRange(PyObject *self, PyObject *args)
+BufferRange(BufferObject *self, PyObject *args)
 {
     PyInt start;
     PyInt end;
 
-    if (CheckBuffer((BufferObject *)(self)))
+    if (CheckBuffer(self))
 	return NULL;
 
     if (!PyArg_ParseTuple(args, "nn", &start, &end))
 	return NULL;
 
-    return RangeNew(((BufferObject *)(self))->buf, start, end);
+    return RangeNew(self->buf, start, end);
 }
 
     static PyObject *
-BufferRepr(PyObject *self)
+BufferRepr(BufferObject *self)
 {
     static char repr[100];
-    BufferObject *this = (BufferObject *)(self);
 
-    if (this->buf == INVALID_BUFFER_VALUE)
+    if (self->buf == INVALID_BUFFER_VALUE)
     {
 	vim_snprintf(repr, 100, _("<buffer object (deleted) at %p>"), (self));
 	return PyString_FromString(repr);
     }
     else
     {
-	char *name = (char *)this->buf->b_fname;
+	char *name = (char *)self->buf->b_fname;
 	PyInt len;
 
 	if (name == NULL)
@@ -3185,14 +3146,14 @@
 }
 
 static struct PyMethodDef BufferMethods[] = {
-    /* name,	    function,		calling,    documentation */
-    {"append",	    BufferAppend,	1,	    "Append data to Vim buffer" },
-    {"mark",	    BufferMark,		1,	    "Return (row,col) representing position of named mark" },
-    {"range",	    BufferRange,	1,	    "Return a range object which represents the part of the given buffer between line numbers s and e" },
+    /* name,	    function,			calling,	documentation */
+    {"append",	    (PyCFunction)BufferAppend,	METH_VARARGS,	"Append data to Vim buffer" },
+    {"mark",	    (PyCFunction)BufferMark,	METH_VARARGS,	"Return (row,col) representing position of named mark" },
+    {"range",	    (PyCFunction)BufferRange,	METH_VARARGS,	"Return a range object which represents the part of the given buffer between line numbers s and e" },
 #if PY_VERSION_HEX >= 0x03000000
-    {"__dir__",	    BufferDir,		4,	    "List its attributes" },
+    {"__dir__",	    (PyCFunction)BufferDir,	METH_NOARGS,	"List buffer attributes" },
 #endif
-    { NULL,	    NULL,		0,	    NULL }
+    { NULL,	    NULL,			0,		NULL }
 };
 
 /*
@@ -4021,14 +3982,14 @@
     OutputType.tp_doc = "vim message object";
     OutputType.tp_methods = OutputMethods;
 #if PY_MAJOR_VERSION >= 3
-    OutputType.tp_getattro = OutputGetattro;
-    OutputType.tp_setattro = OutputSetattro;
+    OutputType.tp_getattro = (getattrofunc)OutputGetattro;
+    OutputType.tp_setattro = (setattrofunc)OutputSetattro;
     OutputType.tp_alloc = call_PyType_GenericAlloc;
     OutputType.tp_new = call_PyType_GenericNew;
     OutputType.tp_free = call_PyObject_Free;
 #else
-    OutputType.tp_getattr = OutputGetattr;
-    OutputType.tp_setattr = OutputSetattr;
+    OutputType.tp_getattr = (getattrfunc)OutputGetattr;
+    OutputType.tp_setattr = (setattrfunc)OutputSetattr;
 #endif
 
     vim_memset(&IterType, 0, sizeof(IterType));
@@ -4036,67 +3997,67 @@
     IterType.tp_basicsize = sizeof(IterObject);
     IterType.tp_flags = Py_TPFLAGS_DEFAULT;
     IterType.tp_doc = "generic iterator object";
-    IterType.tp_iter = IterIter;
-    IterType.tp_iternext = IterNext;
-    IterType.tp_dealloc = IterDestructor;
-    IterType.tp_traverse = IterTraverse;
-    IterType.tp_clear = IterClear;
+    IterType.tp_iter = (getiterfunc)IterIter;
+    IterType.tp_iternext = (iternextfunc)IterNext;
+    IterType.tp_dealloc = (destructor)IterDestructor;
+    IterType.tp_traverse = (traverseproc)IterTraverse;
+    IterType.tp_clear = (inquiry)IterClear;
 
     vim_memset(&BufferType, 0, sizeof(BufferType));
     BufferType.tp_name = "vim.buffer";
     BufferType.tp_basicsize = sizeof(BufferType);
-    BufferType.tp_dealloc = BufferDestructor;
-    BufferType.tp_repr = BufferRepr;
+    BufferType.tp_dealloc = (destructor)BufferDestructor;
+    BufferType.tp_repr = (reprfunc)BufferRepr;
     BufferType.tp_as_sequence = &BufferAsSeq;
     BufferType.tp_as_mapping = &BufferAsMapping;
     BufferType.tp_flags = Py_TPFLAGS_DEFAULT;
     BufferType.tp_doc = "vim buffer object";
     BufferType.tp_methods = BufferMethods;
 #if PY_MAJOR_VERSION >= 3
-    BufferType.tp_getattro = BufferGetattro;
+    BufferType.tp_getattro = (getattrofunc)BufferGetattro;
     BufferType.tp_alloc = call_PyType_GenericAlloc;
     BufferType.tp_new = call_PyType_GenericNew;
     BufferType.tp_free = call_PyObject_Free;
 #else
-    BufferType.tp_getattr = BufferGetattr;
+    BufferType.tp_getattr = (getattrfunc)BufferGetattr;
 #endif
 
     vim_memset(&WindowType, 0, sizeof(WindowType));
     WindowType.tp_name = "vim.window";
     WindowType.tp_basicsize = sizeof(WindowObject);
-    WindowType.tp_dealloc = WindowDestructor;
-    WindowType.tp_repr = WindowRepr;
+    WindowType.tp_dealloc = (destructor)WindowDestructor;
+    WindowType.tp_repr = (reprfunc)WindowRepr;
     WindowType.tp_flags = Py_TPFLAGS_DEFAULT;
     WindowType.tp_doc = "vim Window object";
     WindowType.tp_methods = WindowMethods;
-    WindowType.tp_traverse = WindowTraverse;
-    WindowType.tp_clear = WindowClear;
+    WindowType.tp_traverse = (traverseproc)WindowTraverse;
+    WindowType.tp_clear = (inquiry)WindowClear;
 #if PY_MAJOR_VERSION >= 3
-    WindowType.tp_getattro = WindowGetattro;
-    WindowType.tp_setattro = WindowSetattro;
+    WindowType.tp_getattro = (getattrofunc)WindowGetattro;
+    WindowType.tp_setattro = (setattrofunc)WindowSetattro;
     WindowType.tp_alloc = call_PyType_GenericAlloc;
     WindowType.tp_new = call_PyType_GenericNew;
     WindowType.tp_free = call_PyObject_Free;
 #else
-    WindowType.tp_getattr = WindowGetattr;
-    WindowType.tp_setattr = WindowSetattr;
+    WindowType.tp_getattr = (getattrfunc)WindowGetattr;
+    WindowType.tp_setattr = (setattrfunc)WindowSetattr;
 #endif
 
     vim_memset(&TabPageType, 0, sizeof(TabPageType));
     TabPageType.tp_name = "vim.tabpage";
     TabPageType.tp_basicsize = sizeof(TabPageObject);
-    TabPageType.tp_dealloc = TabPageDestructor;
-    TabPageType.tp_repr = TabPageRepr;
+    TabPageType.tp_dealloc = (destructor)TabPageDestructor;
+    TabPageType.tp_repr = (reprfunc)TabPageRepr;
     TabPageType.tp_flags = Py_TPFLAGS_DEFAULT;
     TabPageType.tp_doc = "vim tab page object";
     TabPageType.tp_methods = TabPageMethods;
 #if PY_MAJOR_VERSION >= 3
-    TabPageType.tp_getattro = TabPageGetattro;
+    TabPageType.tp_getattro = (getattrofunc)TabPageGetattro;
     TabPageType.tp_alloc = call_PyType_GenericAlloc;
     TabPageType.tp_new = call_PyType_GenericNew;
     TabPageType.tp_free = call_PyObject_Free;
 #else
-    TabPageType.tp_getattr = TabPageGetattr;
+    TabPageType.tp_getattr = (getattrfunc)TabPageGetattr;
 #endif
 
     vim_memset(&BufMapType, 0, sizeof(BufMapType));
@@ -4113,7 +4074,7 @@
     WinListType.tp_as_sequence = &WinListAsSeq;
     WinListType.tp_flags = Py_TPFLAGS_DEFAULT;
     WinListType.tp_doc = "vim window list";
-    WinListType.tp_dealloc = WinListDestructor;
+    WinListType.tp_dealloc = (destructor)WinListDestructor;
 
     vim_memset(&TabListType, 0, sizeof(TabListType));
     TabListType.tp_name = "vim.tabpagelist";
@@ -4125,20 +4086,20 @@
     vim_memset(&RangeType, 0, sizeof(RangeType));
     RangeType.tp_name = "vim.range";
     RangeType.tp_basicsize = sizeof(RangeObject);
-    RangeType.tp_dealloc = RangeDestructor;
-    RangeType.tp_repr = RangeRepr;
+    RangeType.tp_dealloc = (destructor)RangeDestructor;
+    RangeType.tp_repr = (reprfunc)RangeRepr;
     RangeType.tp_as_sequence = &RangeAsSeq;
     RangeType.tp_as_mapping = &RangeAsMapping;
     RangeType.tp_flags = Py_TPFLAGS_DEFAULT;
     RangeType.tp_doc = "vim Range object";
     RangeType.tp_methods = RangeMethods;
 #if PY_MAJOR_VERSION >= 3
-    RangeType.tp_getattro = RangeGetattro;
+    RangeType.tp_getattro = (getattrofunc)RangeGetattro;
     RangeType.tp_alloc = call_PyType_GenericAlloc;
     RangeType.tp_new = call_PyType_GenericNew;
     RangeType.tp_free = call_PyObject_Free;
 #else
-    RangeType.tp_getattr = RangeGetattr;
+    RangeType.tp_getattr = (getattrfunc)RangeGetattr;
 #endif
 
     vim_memset(&CurrentType, 0, sizeof(CurrentType));
@@ -4147,59 +4108,59 @@
     CurrentType.tp_flags = Py_TPFLAGS_DEFAULT;
     CurrentType.tp_doc = "vim current object";
 #if PY_MAJOR_VERSION >= 3
-    CurrentType.tp_getattro = CurrentGetattro;
-    CurrentType.tp_setattro = CurrentSetattro;
+    CurrentType.tp_getattro = (getattrofunc)CurrentGetattro;
+    CurrentType.tp_setattro = (setattrofunc)CurrentSetattro;
 #else
-    CurrentType.tp_getattr = CurrentGetattr;
-    CurrentType.tp_setattr = CurrentSetattr;
+    CurrentType.tp_getattr = (getattrfunc)CurrentGetattr;
+    CurrentType.tp_setattr = (setattrfunc)CurrentSetattr;
 #endif
 
     vim_memset(&DictionaryType, 0, sizeof(DictionaryType));
     DictionaryType.tp_name = "vim.dictionary";
     DictionaryType.tp_basicsize = sizeof(DictionaryObject);
-    DictionaryType.tp_dealloc = DictionaryDestructor;
+    DictionaryType.tp_dealloc = (destructor)DictionaryDestructor;
     DictionaryType.tp_as_mapping = &DictionaryAsMapping;
     DictionaryType.tp_flags = Py_TPFLAGS_DEFAULT;
     DictionaryType.tp_doc = "dictionary pushing modifications to vim structure";
     DictionaryType.tp_methods = DictionaryMethods;
 #if PY_MAJOR_VERSION >= 3
-    DictionaryType.tp_getattro = DictionaryGetattro;
-    DictionaryType.tp_setattro = DictionarySetattro;
+    DictionaryType.tp_getattro = (getattrofunc)DictionaryGetattro;
+    DictionaryType.tp_setattro = (setattrofunc)DictionarySetattro;
 #else
-    DictionaryType.tp_getattr = DictionaryGetattr;
-    DictionaryType.tp_setattr = DictionarySetattr;
+    DictionaryType.tp_getattr = (getattrfunc)DictionaryGetattr;
+    DictionaryType.tp_setattr = (setattrfunc)DictionarySetattr;
 #endif
 
     vim_memset(&ListType, 0, sizeof(ListType));
     ListType.tp_name = "vim.list";
-    ListType.tp_dealloc = ListDestructor;
+    ListType.tp_dealloc = (destructor)ListDestructor;
     ListType.tp_basicsize = sizeof(ListObject);
     ListType.tp_as_sequence = &ListAsSeq;
     ListType.tp_as_mapping = &ListAsMapping;
     ListType.tp_flags = Py_TPFLAGS_DEFAULT;
     ListType.tp_doc = "list pushing modifications to vim structure";
     ListType.tp_methods = ListMethods;
-    ListType.tp_iter = ListIter;
+    ListType.tp_iter = (getiterfunc)ListIter;
 #if PY_MAJOR_VERSION >= 3
-    ListType.tp_getattro = ListGetattro;
-    ListType.tp_setattro = ListSetattro;
+    ListType.tp_getattro = (getattrofunc)ListGetattro;
+    ListType.tp_setattro = (setattrofunc)ListSetattro;
 #else
-    ListType.tp_getattr = ListGetattr;
-    ListType.tp_setattr = ListSetattr;
+    ListType.tp_getattr = (getattrfunc)ListGetattr;
+    ListType.tp_setattr = (setattrfunc)ListSetattr;
 #endif
 
     vim_memset(&FunctionType, 0, sizeof(FunctionType));
     FunctionType.tp_name = "vim.function";
     FunctionType.tp_basicsize = sizeof(FunctionObject);
-    FunctionType.tp_dealloc = FunctionDestructor;
-    FunctionType.tp_call = FunctionCall;
+    FunctionType.tp_dealloc = (destructor)FunctionDestructor;
+    FunctionType.tp_call = (ternaryfunc)FunctionCall;
     FunctionType.tp_flags = Py_TPFLAGS_DEFAULT;
     FunctionType.tp_doc = "object that calls vim function";
     FunctionType.tp_methods = FunctionMethods;
 #if PY_MAJOR_VERSION >= 3
-    FunctionType.tp_getattro = FunctionGetattro;
+    FunctionType.tp_getattro = (getattrofunc)FunctionGetattro;
 #else
-    FunctionType.tp_getattr = FunctionGetattr;
+    FunctionType.tp_getattr = (getattrfunc)FunctionGetattr;
 #endif
 
     vim_memset(&OptionsType, 0, sizeof(OptionsType));
@@ -4208,9 +4169,9 @@
     OptionsType.tp_flags = Py_TPFLAGS_DEFAULT;
     OptionsType.tp_doc = "object for manipulating options";
     OptionsType.tp_as_mapping = &OptionsAsMapping;
-    OptionsType.tp_dealloc = OptionsDestructor;
-    OptionsType.tp_traverse = OptionsTraverse;
-    OptionsType.tp_clear = OptionsClear;
+    OptionsType.tp_dealloc = (destructor)OptionsDestructor;
+    OptionsType.tp_traverse = (traverseproc)OptionsTraverse;
+    OptionsType.tp_clear = (inquiry)OptionsClear;
 
 #if PY_MAJOR_VERSION >= 3
     vim_memset(&vimmodule, 0, sizeof(vimmodule));