updated for version 7.3.992v7.3.992

Problem:    Python: Too many type casts.
Solution:   Change argument types. (ZyX)

4 files changed, 285 insertions, 345 deletions

diff --git a/src/if_py_both.h b/src/if_py_both.h
index fd500330ef..e60c35d37f 100644
--- a/src/if_py_both.h
+++ b/src/if_py_both.h
@@ -76,7 +76,7 @@ typedef struct
 } OutputObject;
 
     static int
-OutputSetattr(PyObject *self, char *name, PyObject *val)
+OutputSetattr(OutputObject *self, char *name, PyObject *val)
 {
     if (val == NULL)
     {
@@ -93,7 +93,7 @@ OutputSetattr(PyObject *self, char *name, PyObject *val)
 	    return -1;
 	}
 
-	((OutputObject *)(self))->softspace = PyInt_AsLong(val);
+	self->softspace = PyInt_AsLong(val);
 	return 0;
     }
 
@@ -152,11 +152,11 @@ writer(writefn fn, char_u *str, PyInt n)
 }
 
     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 @@ OutputWrite(PyObject *self, PyObject *args)
 }
 
     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 @@ OutputWritelines(PyObject *self, PyObject *args)
 }
 
     static PyObject *
-OutputFlush(PyObject *self UNUSED, PyObject *args UNUSED)
+OutputFlush(PyObject *self UNUSED)
 {
     /* do nothing */
     Py_INCREF(Py_None);
@@ -230,11 +230,11 @@ OutputFlush(PyObject *self UNUSED, PyObject *args UNUSED)
 /***************/
 
 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 @@ VimStrwidth(PyObject *self UNUSED, PyObject *args)
  */
 
 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 @@ IterNew(void *start, destructorfun destruct, nextfun next, traversefun traverse,
 }
 
     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 @@ IterTraverse(PyObject *self, visitproc visit, void *arg)
 #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 @@ DictionaryNew(dict_T *dict)
 }
 
     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 @@ DictionarySetattr(PyObject *self, char *name, PyObject *val)
 
     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 @@ DictionarySetattr(PyObject *self, char *name, PyObject *val)
 	    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 @@ DictionarySetattr(PyObject *self, char *name, PyObject *val)
 }
 
     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 @@ DictionaryItem(PyObject *self, PyObject *keyObject)
 
     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 @@ DictionaryItem(PyObject *self, PyObject *keyObject)
 }
 
     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 @@ DictionaryAssItem(PyObject *self, PyObject *keyObject, PyObject *valObject)
 }
 
     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 PyMappingMethods DictionaryAsMapping = {
 };
 
 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 @@ ListNew(list_T *list)
 }
 
     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 @@ list_py_concat(list_T *l, PyObject *obj, PyObject *lookupDict)
 }
 
     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 @@ ListItem(PyObject *self, Py_ssize_t index)
 	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 @@ ListIterNext(listiterinfo_T **lii)
 }
 
     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 @@ ListIter(PyObject *self)
 }
 
     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 @@ ListAssItem(PyObject *self, Py_ssize_t index, PyObject *obj)
 }
 
     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 @@ ListAssSlice(PyObject *self, Py_ssize_t first, Py_ssize_t last, PyObject *obj)
     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 @@ ListAssSlice(PyObject *self, Py_ssize_t first, Py_ssize_t last, PyObject *obj)
 }
 
     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 @@ ListConcatInPlace(PyObject *self, PyObject *obj)
     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 @@ ListSetattr(PyObject *self, char *name, PyObject *val)
 
     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 @@ ListSetattr(PyObject *self, char *name, PyObject *val)
 	    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 @@ ListSetattr(PyObject *self, char *name, PyObject *val)
 }
 
 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 @@ FunctionNew(char_u *name)
 }
 
     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 @@ FunctionCall(PyObject *self, PyObject *argsObject, PyObject *kwargs)
 }
 
 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 @@ OptionsNew(int opt_type, void *from, checkfun Check, PyObject *fromObj)
 }
 
     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 @@ OptionsItem(OptionsObject *this, PyObject *keyObject)
     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 @@ set_option_value_for(key, numval, stringval, opt_flags, opt_type, from)
 }
 
     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 @@ OptionsAssItem(OptionsObject *this, PyObject *keyObject, PyObject *valObject)
     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 @@ OptionsAssItem(OptionsObject *this, PyObject *keyObject, PyObject *valObject)
 
     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 @@ OptionsAssItem(OptionsObject *this, PyObject *keyObject, PyObject *valObject)
 	}
 	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 @@ OptionsAssItem(OptionsObject *this, PyObject *keyObject, PyObject *valObject)
 	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 @@ OptionsAssItem(OptionsObject *this, PyObject *keyObject, PyObject *valObject)
 	}
 
 	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 @@ OptionsAssItem(OptionsObject *this, PyObject *keyObject, PyObject *valObject)
 	}
 
 	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 PyObject *WinListNew(TabPageObject *tabObject);
 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 @@ TabPageNew(tabpage_T *tab)
 }
 
     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 @@ typedef struct
 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 @@ WindowNew(win_T *win, tabpage_T *tab)
 }
 
     static void
-WindowDestructor(PyObject *self)
+WindowDestructor(WindowObject *self)
 {
-    WindowObject *this = (WindowObject *)(self);
-
-    if (this->win && this->win != INVALID_WINDOW_VALUE)
-	WIN_PYTHON_REF(this->win) = NULL;
+    if (self->win && self->win != INVALID_WINDOW_VALUE)
+	WIN_PYTHON_REF(self->win) = NULL;
 
-    Py_DECREF(((PyObject *)(this->tabObject)));
+    Py_DECREF(((PyObject *)(self->tabObject)));
 
     DESTRUCTOR_FINISH(self);
 }
@@ -1899,58 +1875,58 @@ get_firstwin(TabPageObject *tabObject)
 	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 @@ WindowAttr(WindowObject *this, char *name)
 }
 
     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 @@ WindowSetattr(PyObject *self, char *name, PyObject *val)
 	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 @@ WindowSetattr(PyObject *self, char *name, PyObject *val)
 	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 @@ WindowSetattr(PyObject *self, char *name, PyObject *val)
 	need_mouse_correct = TRUE;
 #endif
 	savewin = curwin;
-	curwin = this->win;
+	curwin = self->win;
 	win_setheight(height);
 	curwin = savewin;
 
@@ -2036,7 +2010,7 @@ WindowSetattr(PyObject *self, char *name, PyObject *val)
 	need_mouse_correct = TRUE;
 #endif
 	savewin = curwin;
-	curwin = this->win;
+	curwin = self->win;
 	win_setwidth(width);
 	curwin = savewin;
 
@@ -2055,19 +2029,18 @@ WindowSetattr(PyObject *self, char *name, PyObject *val)
 }
 
     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 @@ WinListNew(TabPageObject *tabObject)
 }
 
     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 @@ WinListDestructor(PyObject *self)
 }
 
     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 @@ WinListLength(PyObject *self)
 }
 
     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 @@ typedef struct
 } 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 @@ RangeNew(buf_T *buf, PyInt start, PyInt end)
 }
 
     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 @@ RangeRepr(PyObject *self)
     }
     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 @@ RangeRepr(PyObject *self)
 
 	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 @@ BufferNew(buf_T *buf)
 }
 
     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 @@ BufferAttr(BufferObject *this, char *name)
 }
 
     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,