} OutputObject;
static int
-OutputSetattr(PyObject *self, char *name, PyObject *val)
+OutputSetattr(OutputObject *self, char *name, PyObject *val)
{
if (val == NULL)
{
return -1;
}
- ((OutputObject *)(self))->softspace = PyInt_AsLong(val);
+ self->softspace = PyInt_AsLong(val);
return 0;
}
}
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;
}
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;
}
static PyObject *
-OutputFlush(PyObject *self UNUSED, PyObject *args UNUSED)
+OutputFlush(PyObject *self UNUSED)
{
/* do nothing */
Py_INCREF(Py_None);
/***************/
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 =
*/
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 }
};
/*
}
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;
}
#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 *
}
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"));
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;
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;
}
}
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;
DICTKEY_GET_NOTEMPTY(NULL)
- di = dict_find(((DictionaryObject *) (self))->dict, key, -1);
+ di = dict_find(self->dict, key, -1);
DICTKEY_UNREF
}
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
}
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;
};
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;
}
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);
}
}
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"));
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);
}
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)))
{
}
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);
}
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;
listitem_T *li;
listitem_T *next;
typval_T v;
- list_T *l = ((ListObject *) (self))->list;
+ list_T *l = self->list;
if (l->lv_lock)
{
}
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)
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,
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;
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;
}
}
static struct PyMethodDef ListMethods[] = {
- {"extend", (PyCFunction)ListConcatInPlace, METH_O, ""},
- { NULL, NULL, 0, NULL }
+ {"extend", (PyCFunction)ListConcatInPlace, METH_O, ""},
+ { NULL, NULL, 0, NULL }
};
typedef struct
}
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;
}
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}
};
/*
}
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;
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
}
static int
-OptionsAssItem(OptionsObject *this, PyObject *keyObject, PyObject *valObject)
+OptionsAssItem(OptionsObject *self, PyObject *keyObject, PyObject *valObject)
{
char_u *key;
int flags;
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
if (valObject == NULL)
{
- if (this->opt_type == SREQ_GLOBAL)
+ if (self->opt_type == SREQ_GLOBAL)
{
PyErr_SetString(PyExc_ValueError,
_("unable to unset global option"));
}
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)
{
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)
{
}
r = set_option_value_for(key, val, NULL, opt_flags,
- this->opt_type, this->from);
+ self->opt_type, self->from);
}
else
{
}
r = set_option_value_for(key, 0, val, opt_flags,
- this->opt_type, this->from);
+ self->opt_type, self->from);
vim_free(val);
}
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;
}
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>"),
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;
}
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);
}
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",
}
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)
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;
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;
need_mouse_correct = TRUE;
#endif
savewin = curwin;
- curwin = this->win;
+ curwin = self->win;
win_setheight(height);
curwin = savewin;
need_mouse_correct = TRUE;
#endif
savewin = curwin;
- curwin = this->win;
+ curwin = self->win;
win_setwidth(width);
curwin = savewin;
}
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>"),
}
static void
-WinListDestructor(PyObject *self)
+WinListDestructor(WinListObject *self)
{
- TabPageObject *tabObject = ((WinListObject *)(self))->tabObject;
+ TabPageObject *tabObject = self->tabObject;
if (tabObject)
Py_DECREF((PyObject *)(tabObject));
}
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)
}
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;
} 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;
}
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));
}
else
{
- char *name = (char *)this->buf->buf->b_fname;
+ char *name = (char *)self->buf->buf->b_fname;
int len;
if (name == NULL)
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;
}
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
}
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);
}
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)
}
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 }
};
/*
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));
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));
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";
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));
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));
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));
projects / thirdparty / vim.git / commitdiff
