thac0/vim
1
0
Fork 0
forked from aniani/vim
Code
vim/src/if_py_both.h
Bram Moolenaar b983f75d22 updated for version 7.3.954 
Problem:    No check if PyObject_IsTrue fails.
Solution:   Add a check for -1 value. (ZyX)
2013-05-15 16:11:50 +02:00

3994 lines
84 KiB
C
Raw Blame History

/* vi:set ts=8 sts=4 sw=4 noet:
*
* VIM - Vi IMproved by Bram Moolenaar
*
* Do ":help uganda" in Vim to read copying and usage conditions.
* Do ":help credits" in Vim to see a list of people who contributed.
* See README.txt for an overview of the Vim source code.
*/
/*
* Python extensions by Paul Moore, David Leonard, Roland Puntaier, Nikolay
* Pavlov.
*
* Common code for if_python.c and if_python3.c.
*/
#if PY_VERSION_HEX < 0x02050000
typedef int Py_ssize_t; /* Python 2.4 and earlier don't have this type. */
#endif
#ifdef FEAT_MBYTE
# define ENC_OPT p_enc
#else
# define ENC_OPT "latin1"
#endif
#define PyErr_SetVim(str) PyErr_SetString(VimError, str)
#define INVALID_BUFFER_VALUE ((buf_T *)(-1))
#define INVALID_WINDOW_VALUE ((win_T *)(-1))
#define INVALID_TABPAGE_VALUE ((tabpage_T *)(-1))
static int ConvertFromPyObject(PyObject *, typval_T *);
static int _ConvertFromPyObject(PyObject *, typval_T *, PyObject *);
static PyInt RangeStart;
static PyInt RangeEnd;
/*
* obtain a lock on the Vim data structures
*/
static void
Python_Lock_Vim(void)
{
}
/*
* release a lock on the Vim data structures
*/
static void
Python_Release_Vim(void)
{
}
/* Output buffer management
*/
/* Function to write a line, points to either msg() or emsg(). */
typedef void (*writefn)(char_u *);
static PyTypeObject OutputType;
typedef struct
{
PyObject_HEAD
long softspace;
long error;
} OutputObject;
static int
OutputSetattr(PyObject *self, char *name, PyObject *val)
{
if (val == NULL)
{
PyErr_SetString(PyExc_AttributeError,
_("can't delete OutputObject attributes"));
return -1;
}
if (strcmp(name, "softspace") == 0)
{
if (!PyInt_Check(val))
{
PyErr_SetString(PyExc_TypeError, _("softspace must be an integer"));
return -1;
}
((OutputObject *)(self))->softspace = PyInt_AsLong(val);
return 0;
}
PyErr_SetString(PyExc_AttributeError, _("invalid attribute"));
return -1;
}
/* Buffer IO, we write one whole line at a time. */
static garray_T io_ga = {0, 0, 1, 80, NULL};
static writefn old_fn = NULL;
static void
PythonIO_Flush(void)
{
if (old_fn != NULL && io_ga.ga_len > 0)
{
((char_u *)io_ga.ga_data)[io_ga.ga_len] = NUL;
old_fn((char_u *)io_ga.ga_data);
}
io_ga.ga_len = 0;
}
static void
writer(writefn fn, char_u *str, PyInt n)
{
char_u *ptr;
/* Flush when switching output function. */
if (fn != old_fn)
PythonIO_Flush();
old_fn = fn;
/* Write each NL separated line. Text after the last NL is kept for
* writing later. */
while (n > 0 && (ptr = memchr(str, '\n', n)) != NULL)
{
PyInt len = ptr - str;
if (ga_grow(&io_ga, (int)(len + 1)) == FAIL)
break;
mch_memmove(((char *)io_ga.ga_data) + io_ga.ga_len, str, (size_t)len);
((char *)io_ga.ga_data)[io_ga.ga_len + len] = NUL;
fn((char_u *)io_ga.ga_data);
str = ptr + 1;
n -= len + 1;
io_ga.ga_len = 0;
}
/* Put the remaining text into io_ga for later printing. */
if (n > 0 && ga_grow(&io_ga, (int)(n + 1)) == OK)
{
mch_memmove(((char *)io_ga.ga_data) + io_ga.ga_len, str, (size_t)n);
io_ga.ga_len += (int)n;
}
}
static PyObject *
OutputWrite(PyObject *self, PyObject *args)
{
Py_ssize_t len = 0;
char *str = NULL;
int error = ((OutputObject *)(self))->error;
if (!PyArg_ParseTuple(args, "et#", ENC_OPT, &str, &len))
return NULL;
Py_BEGIN_ALLOW_THREADS
Python_Lock_Vim();
writer((writefn)(error ? emsg : msg), (char_u *)str, len);
Python_Release_Vim();
Py_END_ALLOW_THREADS
PyMem_Free(str);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
OutputWritelines(PyObject *self, PyObject *args)
{
PyInt n;
PyInt i;
PyObject *list;
int error = ((OutputObject *)(self))->error;
if (!PyArg_ParseTuple(args, "O", &list))
return NULL;
Py_INCREF(list);
if (!PyList_Check(list))
{
PyErr_SetString(PyExc_TypeError, _("writelines() requires list of strings"));
Py_DECREF(list);
return NULL;
}
n = PyList_Size(list);
for (i = 0; i < n; ++i)
{
PyObject *line = PyList_GetItem(list, i);
char *str = NULL;
PyInt len;
if (!PyArg_Parse(line, "et#", ENC_OPT, &str, &len))
{
PyErr_SetString(PyExc_TypeError, _("writelines() requires list of strings"));
Py_DECREF(list);
return NULL;
}
Py_BEGIN_ALLOW_THREADS
Python_Lock_Vim();
writer((writefn)(error ? emsg : msg), (char_u *)str, len);
Python_Release_Vim();
Py_END_ALLOW_THREADS
PyMem_Free(str);
}
Py_DECREF(list);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
OutputFlush(PyObject *self UNUSED, PyObject *args UNUSED)
{
/* do nothing */
Py_INCREF(Py_None);
return Py_None;
}
/***************/
static struct PyMethodDef OutputMethods[] = {
/* name, function, calling, documentation */
{"write", OutputWrite, 1, ""},
{"writelines", OutputWritelines, 1, ""},
{"flush", OutputFlush, 1, ""},
{ NULL, NULL, 0, NULL}
};
static OutputObject Output =
{
PyObject_HEAD_INIT(&OutputType)
0,
0
};
static OutputObject Error =
{
PyObject_HEAD_INIT(&OutputType)
0,
1
};
static int
PythonIO_Init_io(void)
{
PySys_SetObject("stdout", (PyObject *)(void *)&Output);
PySys_SetObject("stderr", (PyObject *)(void *)&Error);
if (PyErr_Occurred())
{
EMSG(_("E264: Python: Error initialising I/O objects"));
return -1;
}
return 0;
}
static PyObject *VimError;
/* Check to see whether a Vim error has been reported, or a keyboard
* interrupt has been detected.
*/
static int
VimErrorCheck(void)
{
if (got_int)
{
PyErr_SetNone(PyExc_KeyboardInterrupt);
return 1;
}
else if (did_emsg && !PyErr_Occurred())
{
PyErr_SetNone(VimError);
return 1;
}
return 0;
}
/* Vim module - Implementation
*/
static PyObject *
VimCommand(PyObject *self UNUSED, PyObject *args)
{
char *cmd;
PyObject *result;
if (!PyArg_ParseTuple(args, "s", &cmd))
return NULL;
PyErr_Clear();
Py_BEGIN_ALLOW_THREADS
Python_Lock_Vim();
do_cmdline_cmd((char_u *)cmd);
update_screen(VALID);
Python_Release_Vim();
Py_END_ALLOW_THREADS
if (VimErrorCheck())
result = NULL;
else
result = Py_None;
Py_XINCREF(result);
return result;
}
/*
* Function to translate a typval_T into a PyObject; this will recursively
* translate lists/dictionaries into their Python equivalents.
*
* The depth parameter is to avoid infinite recursion, set it to 1 when
* you call VimToPython.
*/
static PyObject *
VimToPython(typval_T *our_tv, int depth, PyObject *lookupDict)
{
PyObject *result;
PyObject *newObj;
char ptrBuf[sizeof(void *) * 2 + 3];
/* Avoid infinite recursion */
if (depth > 100)
{
Py_INCREF(Py_None);
result = Py_None;
return result;
}
/* Check if we run into a recursive loop. The item must be in lookupDict
* then and we can use it again. */
if ((our_tv->v_type == VAR_LIST && our_tv->vval.v_list != NULL)
|| (our_tv->v_type == VAR_DICT && our_tv->vval.v_dict != NULL))
{
sprintf(ptrBuf, "%p",
our_tv->v_type == VAR_LIST ? (void *)our_tv->vval.v_list
: (void *)our_tv->vval.v_dict);
result = PyDict_GetItemString(lookupDict, ptrBuf);
if (result != NULL)
{
Py_INCREF(result);
return result;
}
}
if (our_tv->v_type == VAR_STRING)
{
result = Py_BuildValue("s", our_tv->vval.v_string == NULL
? "" : (char *)our_tv->vval.v_string);
}
else if (our_tv->v_type == VAR_NUMBER)
{
char buf[NUMBUFLEN];
/* For backwards compatibility numbers are stored as strings. */
sprintf(buf, "%ld", (long)our_tv->vval.v_number);
result = Py_BuildValue("s", buf);
}
# ifdef FEAT_FLOAT
else if (our_tv->v_type == VAR_FLOAT)
{
char buf[NUMBUFLEN];
sprintf(buf, "%f", our_tv->vval.v_float);
result = Py_BuildValue("s", buf);
}
# endif
else if (our_tv->v_type == VAR_LIST)
{
list_T *list = our_tv->vval.v_list;
listitem_T *curr;
result = PyList_New(0);
if (list != NULL)
{
PyDict_SetItemString(lookupDict, ptrBuf, result);
for (curr = list->lv_first; curr != NULL; curr = curr->li_next)
{
newObj = VimToPython(&curr->li_tv, depth + 1, lookupDict);
PyList_Append(result, newObj);
Py_DECREF(newObj);
}
}
}
else if (our_tv->v_type == VAR_DICT)
{
result = PyDict_New();
if (our_tv->vval.v_dict != NULL)
{
hashtab_T *ht = &our_tv->vval.v_dict->dv_hashtab;
long_u todo = ht->ht_used;
hashitem_T *hi;
dictitem_T *di;
PyDict_SetItemString(lookupDict, ptrBuf, result);
for (hi = ht->ht_array; todo > 0; ++hi)
{
if (!HASHITEM_EMPTY(hi))
{
--todo;
di = dict_lookup(hi);
newObj = VimToPython(&di->di_tv, depth + 1, lookupDict);
PyDict_SetItemString(result, (char *)hi->hi_key, newObj);
Py_DECREF(newObj);
}
}
}
}
else
{
Py_INCREF(Py_None);
result = Py_None;
}
return result;
}
static PyObject *
VimEval(PyObject *self UNUSED, PyObject *args UNUSED)
{
char *expr;
typval_T *our_tv;
PyObject *result;
PyObject *lookup_dict;
if (!PyArg_ParseTuple(args, "s", &expr))
return NULL;
Py_BEGIN_ALLOW_THREADS
Python_Lock_Vim();
our_tv = eval_expr((char_u *)expr, NULL);
Python_Release_Vim();
Py_END_ALLOW_THREADS
if (our_tv == NULL)
{
PyErr_SetVim(_("invalid expression"));
return NULL;
}
/* Convert the Vim type into a Python type. Create a dictionary that's
* used to check for recursive loops. */
lookup_dict = PyDict_New();
result = VimToPython(our_tv, 1, lookup_dict);
Py_DECREF(lookup_dict);
Py_BEGIN_ALLOW_THREADS
Python_Lock_Vim();
free_tv(our_tv);
Python_Release_Vim();
Py_END_ALLOW_THREADS
return result;
}
static PyObject *ConvertToPyObject(typval_T *);
static PyObject *
VimEvalPy(PyObject *self UNUSED, PyObject *args UNUSED)
{
char *expr;
typval_T *our_tv;
PyObject *result;
if (!PyArg_ParseTuple(args, "s", &expr))
return NULL;
Py_BEGIN_ALLOW_THREADS
Python_Lock_Vim();
our_tv = eval_expr((char_u *)expr, NULL);
Python_Release_Vim();
Py_END_ALLOW_THREADS
if (our_tv == NULL)
{
PyErr_SetVim(_("invalid expression"));
return NULL;
}
result = ConvertToPyObject(our_tv);
Py_BEGIN_ALLOW_THREADS
Python_Lock_Vim();
free_tv(our_tv);
Python_Release_Vim();
Py_END_ALLOW_THREADS
return result;
}
static PyObject *
VimStrwidth(PyObject *self UNUSED, PyObject *args)
{
char *expr;
if (!PyArg_ParseTuple(args, "s", &expr))
return NULL;
return PyLong_FromLong(
#ifdef FEAT_MBYTE
mb_string2cells((char_u *)expr, (int)STRLEN(expr))
#else
STRLEN(expr)
#endif
);
}
/*
* Vim module - Definitions
*/
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 }
};
/*
* Generic iterator object
*/
static PyTypeObject IterType;
typedef PyObject *(*nextfun)(void **);
typedef void (*destructorfun)(void *);
/* Main purpose of this object is removing the need for do python initialization
* (i.e. PyType_Ready and setting type attributes) for a big bunch of objects.
*/
typedef struct
{
PyObject_HEAD
void *cur;
nextfun next;
destructorfun destruct;
} IterObject;
static PyObject *
IterNew(void *start, destructorfun destruct, nextfun next)
{
IterObject *self;
self = PyObject_NEW(IterObject, &IterType);
self->cur = start;
self->next = next;
self->destruct = destruct;
return (PyObject *)(self);
}
#if 0 /* unused */
static void
IterDestructor(PyObject *self)
{
IterObject *this = (IterObject *)(self);
this->destruct(this->cur);
DESTRUCTOR_FINISH(self);
}
#endif
static PyObject *
IterNext(PyObject *self)
{
IterObject *this = (IterObject *)(self);
return this->next(&this->cur);
}
static PyObject *
IterIter(PyObject *self)
{
return self;
}
typedef struct pylinkedlist_S {
struct pylinkedlist_S *pll_next;
struct pylinkedlist_S *pll_prev;
PyObject *pll_obj;
} pylinkedlist_T;
static pylinkedlist_T *lastdict = NULL;
static pylinkedlist_T *lastlist = NULL;
static void
pyll_remove(pylinkedlist_T *ref, pylinkedlist_T **last)
{
if (ref->pll_prev == NULL)
{
if (ref->pll_next == NULL)
{
*last = NULL;
return;
}
}
else
ref->pll_prev->pll_next = ref->pll_next;
if (ref->pll_next == NULL)
*last = ref->pll_prev;
else
ref->pll_next->pll_prev = ref->pll_prev;
}
static void
pyll_add(PyObject *self, pylinkedlist_T *ref, pylinkedlist_T **last)
{
if (*last == NULL)
ref->pll_prev = NULL;
else
{
(*last)->pll_next = ref;
ref->pll_prev = *last;
}
ref->pll_next = NULL;
ref->pll_obj = self;
*last = ref;
}
static PyTypeObject DictionaryType;
#define DICTKEY_GET_NOTEMPTY(err) \
DICTKEY_GET(err) \
if (*key == NUL) \
{ \
PyErr_SetString(PyExc_ValueError, _("empty keys are not allowed")); \
return err; \
}
typedef struct
{
PyObject_HEAD
dict_T *dict;
pylinkedlist_T ref;
} DictionaryObject;
static PyObject *
DictionaryNew(dict_T *dict)
{
DictionaryObject *self;
self = PyObject_NEW(DictionaryObject, &DictionaryType);
if (self == NULL)
return NULL;
self->dict = dict;
++dict->dv_refcount;
pyll_add((PyObject *)(self), &self->ref, &lastdict);
return (PyObject *)(self);
}
static void
DictionaryDestructor(PyObject *self)
{
DictionaryObject *this = ((DictionaryObject *) (self));
pyll_remove(&this->ref, &lastdict);
dict_unref(this->dict);
DESTRUCTOR_FINISH(self);
}
static int
DictionarySetattr(PyObject *self, char *name, PyObject *val)
{
DictionaryObject *this = (DictionaryObject *)(self);
if (val == NULL)
{
PyErr_SetString(PyExc_AttributeError, _("Cannot delete DictionaryObject attributes"));
return -1;
}
if (strcmp(name, "locked") == 0)
{
if (this->dict->dv_lock == VAR_FIXED)
{
PyErr_SetString(PyExc_TypeError, _("Cannot modify fixed dictionary"));
return -1;
}
else
{
int istrue = PyObject_IsTrue(val);
if (istrue == -1)
return -1;
else if (istrue)
this->dict->dv_lock = VAR_LOCKED;
else
this->dict->dv_lock = 0;
}
return 0;
}
else
{
PyErr_SetString(PyExc_AttributeError, _("Cannot set this attribute"));
return -1;
}
}
static PyInt
DictionaryLength(PyObject *self)
{
return ((PyInt) ((((DictionaryObject *)(self))->dict->dv_hashtab.ht_used)));
}
static PyObject *
DictionaryItem(PyObject *self, PyObject *keyObject)
{
char_u *key;
dictitem_T *di;
DICTKEY_DECL
DICTKEY_GET_NOTEMPTY(NULL)
di = dict_find(((DictionaryObject *) (self))->dict, key, -1);
DICTKEY_UNREF
if (di == NULL)
{
PyErr_SetObject(PyExc_KeyError, keyObject);
return NULL;
}
return ConvertToPyObject(&di->di_tv);
}
static PyInt
DictionaryAssItem(PyObject *self, PyObject *keyObject, PyObject *valObject)
{
char_u *key;
typval_T tv;
dict_T *d = ((DictionaryObject *)(self))->dict;
dictitem_T *di;
DICTKEY_DECL
if (d->dv_lock)
{
PyErr_SetVim(_("dict is locked"));
return -1;
}
DICTKEY_GET_NOTEMPTY(-1)
di = dict_find(d, key, -1);
if (valObject == NULL)
{
hashitem_T *hi;
if (di == NULL)
{
DICTKEY_UNREF
PyErr_SetObject(PyExc_KeyError, keyObject);
return -1;
}
hi = hash_find(&d->dv_hashtab, di->di_key);
hash_remove(&d->dv_hashtab, hi);
dictitem_free(di);
return 0;
}
if (ConvertFromPyObject(valObject, &tv) == -1)
return -1;
if (di == NULL)
{
di = dictitem_alloc(key);
if (di == NULL)
{
PyErr_NoMemory();
return -1;
}
di->di_tv.v_lock = 0;
if (dict_add(d, di) == FAIL)
{
DICTKEY_UNREF
vim_free(di);
PyErr_SetVim(_("failed to add key to dictionary"));
return -1;
}
}
else
clear_tv(&di->di_tv);
DICTKEY_UNREF
copy_tv(&tv, &di->di_tv);
return 0;
}
static PyObject *
DictionaryListKeys(PyObject *self UNUSED)
{
dict_T *dict = ((DictionaryObject *)(self))->dict;
long_u todo = dict->dv_hashtab.ht_used;
Py_ssize_t i = 0;
PyObject *r;
hashitem_T *hi;
r = PyList_New(todo);
for (hi = dict->dv_hashtab.ht_array; todo > 0; ++hi)
{
if (!HASHITEM_EMPTY(hi))
{
PyList_SetItem(r, i, PyBytes_FromString((char *)(hi->hi_key)));
--todo;
++i;
}
}
return r;
}
static PyMappingMethods DictionaryAsMapping = {
(lenfunc) DictionaryLength,
(binaryfunc) DictionaryItem,
(objobjargproc) DictionaryAssItem,
};
static struct PyMethodDef DictionaryMethods[] = {
{"keys", (PyCFunction)DictionaryListKeys, METH_NOARGS, ""},
{ NULL, NULL, 0, NULL }
};
static PyTypeObject ListType;
static PySequenceMethods ListAsSeq;
static PyMappingMethods ListAsMapping;
typedef struct
{
PyObject_HEAD
list_T *list;
pylinkedlist_T ref;
} ListObject;
static PyObject *
ListNew(list_T *list)
{
ListObject *self;
self = PyObject_NEW(ListObject, &ListType);
if (self == NULL)
return NULL;
self->list = list;
++list->lv_refcount;
pyll_add((PyObject *)(self), &self->ref, &lastlist);
return (PyObject *)(self);
}
static void
ListDestructor(PyObject *self)
{
ListObject *this = (ListObject *)(self);
pyll_remove(&this->ref, &lastlist);
list_unref(this->list);
DESTRUCTOR_FINISH(self);
}
static int
list_py_concat(list_T *l, PyObject *obj, PyObject *lookupDict)
{
Py_ssize_t i;
Py_ssize_t lsize = PySequence_Size(obj);
PyObject *litem;
listitem_T *li;
for(i=0; i<lsize; i++)
{
li = listitem_alloc();
if (li == NULL)
{
PyErr_NoMemory();
return -1;
}
li->li_tv.v_lock = 0;
litem = PySequence_GetItem(obj, i);
if (litem == NULL)
return -1;
if (_ConvertFromPyObject(litem, &li->li_tv, lookupDict) == -1)
return -1;
list_append(l, li);
}
return 0;
}
static PyInt
ListLength(PyObject *self)
{
return ((PyInt) (((ListObject *) (self))->list->lv_len));
}
static PyObject *
ListItem(PyObject *self, Py_ssize_t index)
{
listitem_T *li;
if (index>=ListLength(self))
{
PyErr_SetString(PyExc_IndexError, _("list index out of range"));
return NULL;
}
li = list_find(((ListObject *) (self))->list, (long) index);
if (li == NULL)
{
PyErr_SetVim(_("internal error: failed to get vim list item"));
return NULL;
}
return ConvertToPyObject(&li->li_tv);
}
#define PROC_RANGE \
if (last < 0) {\
if (last < -size) \
last = 0; \
else \
last += size; \
} \
if (first < 0) \
first = 0; \
if (first > size) \
first = size; \
if (last > size) \
last = size;
static PyObject *
ListSlice(PyObject *self, Py_ssize_t first, Py_ssize_t last)
{
PyInt i;
PyInt size = ListLength(self);
PyInt n;
PyObject *list;
int reversed = 0;
PROC_RANGE
if (first >= last)
first = last;
n = last-first;
list = PyList_New(n);
if (list == NULL)
return NULL;
for (i = 0; i < n; ++i)
{
PyObject *item = ListItem(self, first + i);
if (item == NULL)
{
Py_DECREF(list);
return NULL;
}
if ((PyList_SetItem(list, ((reversed)?(n-i-1):(i)), item)))
{
Py_DECREF(item);
Py_DECREF(list);
return NULL;
}
}
return list;
}
typedef struct
{
listwatch_T lw;
list_T *list;
} listiterinfo_T;
static void
ListIterDestruct(listiterinfo_T *lii)
{
list_rem_watch(lii->list, &lii->lw);
PyMem_Free(lii);
}
static PyObject *
ListIterNext(listiterinfo_T **lii)
{
PyObject *r;
if (!((*lii)->lw.lw_item))
return NULL;
if (!(r = ConvertToPyObject(&((*lii)->lw.lw_item->li_tv))))
return NULL;
(*lii)->lw.lw_item = (*lii)->lw.lw_item->li_next;
return r;
}
static PyObject *
ListIter(PyObject *self)
{
listiterinfo_T *lii;
list_T *l = ((ListObject *) (self))->list;
if (!(lii = PyMem_New(listiterinfo_T, 1)))
{
PyErr_NoMemory();
return NULL;
}
list_add_watch(l, &lii->lw);
lii->lw.lw_item = l->lv_first;
lii->list = l;
return IterNew(lii,
(destructorfun) ListIterDestruct, (nextfun) ListIterNext);
}
static int
ListAssItem(PyObject *self, Py_ssize_t index, PyObject *obj)
{
typval_T tv;
list_T *l = ((ListObject *) (self))->list;
listitem_T *li;
Py_ssize_t length = ListLength(self);
if (l->lv_lock)
{
PyErr_SetVim(_("list is locked"));
return -1;
}
if (index>length || (index==length && obj==NULL))
{
PyErr_SetString(PyExc_IndexError, _("list index out of range"));
return -1;
}
if (obj == NULL)
{
li = list_find(l, (long) index);
list_remove(l, li, li);
clear_tv(&li->li_tv);
vim_free(li);
return 0;
}
if (ConvertFromPyObject(obj, &tv) == -1)
return -1;
if (index == length)
{
if (list_append_tv(l, &tv) == FAIL)
{
PyErr_SetVim(_("Failed to add item to list"));
return -1;
}
}
else
{
li = list_find(l, (long) index);
clear_tv(&li->li_tv);
copy_tv(&tv, &li->li_tv);
}
return 0;
}
static int
ListAssSlice(PyObject *self, Py_ssize_t first, Py_ssize_t last, PyObject *obj)
{
PyInt size = ListLength(self);
Py_ssize_t i;
Py_ssize_t lsize;
PyObject *litem;
listitem_T *li;
listitem_T *next;
typval_T v;
list_T *l = ((ListObject *) (self))->list;
if (l->lv_lock)
{
PyErr_SetVim(_("list is locked"));
return -1;
}
PROC_RANGE
if (first == size)
li = NULL;
else
{
li = list_find(l, (long) first);
if (li == NULL)
{
PyErr_SetVim(_("internal error: no vim list item"));
return -1;
}
if (last > first)
{
i = last - first;
while (i-- && li != NULL)
{
next = li->li_next;
listitem_remove(l, li);
li = next;
}
}
}
if (obj == NULL)
return 0;
if (!PyList_Check(obj))
{
PyErr_SetString(PyExc_TypeError, _("can only assign lists to slice"));
return -1;
}
lsize = PyList_Size(obj);
for(i=0; i<lsize; i++)
{
litem = PyList_GetItem(obj, i);
if (litem == NULL)
return -1;
if (ConvertFromPyObject(litem, &v) == -1)
return -1;
if (list_insert_tv(l, &v, li) == FAIL)
{
PyErr_SetVim(_("internal error: failed to add item to list"));
return -1;
}
}
return 0;
}
static PyObject *
ListConcatInPlace(PyObject *self, PyObject *obj)
{
list_T *l = ((ListObject *) (self))->list;
PyObject *lookup_dict;
if (l->lv_lock)
{
PyErr_SetVim(_("list is locked"));
return NULL;
}
if (!PySequence_Check(obj))
{
PyErr_SetString(PyExc_TypeError, _("can only concatenate with lists"));
return NULL;
}
lookup_dict = PyDict_New();
if (list_py_concat(l, obj, lookup_dict) == -1)
{
Py_DECREF(lookup_dict);
return NULL;
}
Py_DECREF(lookup_dict);
Py_INCREF(self);
return self;
}
static int
ListSetattr(PyObject *self, char *name, PyObject *val)
{
ListObject *this = (ListObject *)(self);
if (val == NULL)
{
PyErr_SetString(PyExc_AttributeError,
_("cannot delete vim.dictionary attributes"));
return -1;
}
if (strcmp(name, "locked") == 0)
{
if (this->list->lv_lock == VAR_FIXED)
{
PyErr_SetString(PyExc_TypeError, _("cannot modify fixed list"));
return -1;
}
else
{
int istrue = PyObject_IsTrue(val);
if (istrue == -1)
return -1;
else if (istrue)
this->list->lv_lock = VAR_LOCKED;
else
this->list->lv_lock = 0;
}
return 0;
}
else
{
PyErr_SetString(PyExc_AttributeError, _("cannot set this attribute"));
return -1;
}
}
static struct PyMethodDef ListMethods[] = {
{"extend", (PyCFunction)ListConcatInPlace, METH_O, ""},
{ NULL, NULL, 0, NULL }
};
typedef struct
{
PyObject_HEAD
char_u *name;
} FunctionObject;
static PyTypeObject FunctionType;
static PyObject *
FunctionNew(char_u *name)
{
FunctionObject *self;
self = PyObject_NEW(FunctionObject, &FunctionType);
if (self == NULL)
return NULL;
self->name = PyMem_New(char_u, STRLEN(name) + 1);
if (self->name == NULL)
{
PyErr_NoMemory();
return NULL;
}
STRCPY(self->name, name);
func_ref(name);
return (PyObject *)(self);
}
static void
FunctionDestructor(PyObject *self)
{
FunctionObject *this = (FunctionObject *) (self);
func_unref(this->name);
PyMem_Del(this->name);
DESTRUCTOR_FINISH(self);
}
static PyObject *
FunctionCall(PyObject *self, PyObject *argsObject, PyObject *kwargs)
{
FunctionObject *this = (FunctionObject *)(self);
char_u *name = this->name;
typval_T args;
typval_T selfdicttv;
typval_T rettv;
dict_T *selfdict = NULL;
PyObject *selfdictObject;
PyObject *result;
int error;
if (ConvertFromPyObject(argsObject, &args) == -1)
return NULL;
if (kwargs != NULL)
{
selfdictObject = PyDict_GetItemString(kwargs, "self");
if (selfdictObject != NULL)
{
if (!PyMapping_Check(selfdictObject))
{
PyErr_SetString(PyExc_TypeError,
_("'self' argument must be a dictionary"));
clear_tv(&args);
return NULL;
}
if (ConvertFromPyObject(selfdictObject, &selfdicttv) == -1)
return NULL;
selfdict = selfdicttv.vval.v_dict;
}
}
error = func_call(name, &args, selfdict, &rettv);
if (error != OK)
{
result = NULL;
PyErr_SetVim(_("failed to run function"));
}
else
result = ConvertToPyObject(&rettv);
/* FIXME Check what should really be cleared. */
clear_tv(&args);
clear_tv(&rettv);
/*
* if (selfdict!=NULL)
* clear_tv(selfdicttv);
*/
return result;
}
static struct PyMethodDef FunctionMethods[] = {
{"__call__", (PyCFunction)FunctionCall, METH_VARARGS|METH_KEYWORDS, ""},
{ NULL, NULL, 0, NULL }
};
/*
* Options object
*/
static PyTypeObject OptionsType;
typedef int (*checkfun)(void *);
typedef struct
{
PyObject_HEAD
int opt_type;
void *from;
checkfun Check;
PyObject *fromObj;
} OptionsObject;
static PyObject *
OptionsItem(OptionsObject *this, PyObject *keyObject)
{
char_u *key;
int flags;
long numval;
char_u *stringval;
DICTKEY_DECL
if (this->Check(this->from))
return NULL;
DICTKEY_GET_NOTEMPTY(NULL)
flags = get_option_value_strict(key, &numval, &stringval,
this->opt_type, this->from);
DICTKEY_UNREF
if (flags == 0)
{
PyErr_SetObject(PyExc_KeyError, keyObject);
return NULL;
}
if (flags & SOPT_UNSET)
{
Py_INCREF(Py_None);
return Py_None;
}
else if (flags & SOPT_BOOL)
{
PyObject *r;
r = numval ? Py_True : Py_False;
Py_INCREF(r);
return r;
}
else if (flags & SOPT_NUM)
return PyInt_FromLong(numval);
else if (flags & SOPT_STRING)
{
if (stringval)
return PyBytes_FromString((char *) stringval);
else
{
PyErr_SetString(PyExc_RuntimeError,
_("unable to get option value"));
return NULL;
}
}
else
{
PyErr_SetVim("Internal error: unknown option type. Should not happen");
return NULL;
}
}
static int
set_option_value_for(key, numval, stringval, opt_flags, opt_type, from)
char_u *key;
int numval;
char_u *stringval;
int opt_flags;
int opt_type;
void *from;
{
win_T *save_curwin;
tabpage_T *save_curtab;
aco_save_T aco;
int r = 0;
switch (opt_type)
{
case SREQ_WIN:
if (switch_win(&save_curwin, &save_curtab, (win_T *) from, curtab)
== FAIL)
{
PyErr_SetVim("Problem while switching windows.");
return -1;
}
set_option_value(key, numval, stringval, opt_flags);
restore_win(save_curwin, save_curtab);
break;
case SREQ_BUF:
aucmd_prepbuf(&aco, (buf_T *) from);
set_option_value(key, numval, stringval, opt_flags);
aucmd_restbuf(&aco);
break;
case SREQ_GLOBAL:
set_option_value(key, numval, stringval, opt_flags);
break;
}
return r;
}
static int
OptionsAssItem(OptionsObject *this, PyObject *keyObject, PyObject *valObject)
{
char_u *key;
int flags;
int opt_flags;
int r = 0;
DICTKEY_DECL
if (this->Check(this->from))
return -1;
DICTKEY_GET_NOTEMPTY(-1)
flags = get_option_value_strict(key, NULL, NULL,
this->opt_type, this->from);
DICTKEY_UNREF
if (flags == 0)
{
PyErr_SetObject(PyExc_KeyError, keyObject);
return -1;
}
if (valObject == NULL)
{
if (this->opt_type == SREQ_GLOBAL)
{
PyErr_SetString(PyExc_ValueError,
_("unable to unset global option"));
return -1;
}
else if (!(flags & SOPT_GLOBAL))
{
PyErr_SetString(PyExc_ValueError, _("unable to unset option "
"without global value"));
return -1;
}
else
{
unset_global_local_option(key, this->from);
return 0;
}
}
opt_flags = (this->opt_type ? OPT_LOCAL : OPT_GLOBAL);
if (flags & SOPT_BOOL)
{
int istrue = PyObject_IsTrue(valObject);
if (istrue == -1)
return -1;
r = set_option_value_for(key, istrue, NULL,
opt_flags, this->opt_type, this->from);
}
else if (flags & SOPT_NUM)
{
int val;
#if PY_MAJOR_VERSION < 3
if (PyInt_Check(valObject))
val = PyInt_AsLong(valObject);
else
#endif
if (PyLong_Check(valObject))
val = PyLong_AsLong(valObject);
else
{
PyErr_SetString(PyExc_TypeError, _("object must be integer"));
return -1;
}
r = set_option_value_for(key, val, NULL, opt_flags,
this->opt_type, this->from);
}
else
{
char_u *val;
if (PyBytes_Check(valObject))
{
if (PyString_AsStringAndSize(valObject, (char **) &val, NULL) == -1)
return -1;
if (val == NULL)
return -1;
val = vim_strsave(val);
}
else if (PyUnicode_Check(valObject))
{
PyObject *bytes;
bytes = PyUnicode_AsEncodedString(valObject, (char *)ENC_OPT, NULL);
if (bytes == NULL)
return -1;
if(PyString_AsStringAndSize(bytes, (char **) &val, NULL) == -1)
return -1;
if (val == NULL)
return -1;
val = vim_strsave(val);
Py_XDECREF(bytes);
}
else
{
PyErr_SetString(PyExc_TypeError, _("object must be string"));
return -1;
}
r = set_option_value_for(key, 0, val, opt_flags,
this->opt_type, this->from);
vim_free(val);
}
return r;
}
static int
dummy_check(void *arg UNUSED)
{
return 0;
}
static PyObject *
OptionsNew(int opt_type, void *from, checkfun Check, PyObject *fromObj)
{
OptionsObject *self;
self = PyObject_NEW(OptionsObject, &OptionsType);
if (self == NULL)
return NULL;
self->opt_type = opt_type;
self->from = from;
self->Check = Check;
self->fromObj = fromObj;
if (fromObj)
Py_INCREF(fromObj);
return (PyObject *)(self);
}
static void
OptionsDestructor(PyObject *self)
{
if (((OptionsObject *)(self))->fromObj)
Py_DECREF(((OptionsObject *)(self))->fromObj);
DESTRUCTOR_FINISH(self);
}
static PyMappingMethods OptionsAsMapping = {
(lenfunc) NULL,
(binaryfunc) OptionsItem,
(objobjargproc) OptionsAssItem,
};
/* Tabpage object
*/
typedef struct
{
PyObject_HEAD
tabpage_T *tab;
} TabPageObject;
static PyObject *WinListNew(TabPageObject *tabObject);
static PyTypeObject TabPageType;
static int
CheckTabPage(TabPageObject *this)
{
if (this->tab == INVALID_TABPAGE_VALUE)
{
PyErr_SetVim(_("attempt to refer to deleted tab page"));
return -1;
}
return 0;
}
static PyObject *
TabPageNew(tabpage_T *tab)
{
TabPageObject *self;
if (TAB_PYTHON_REF(tab))
{
self = TAB_PYTHON_REF(tab);
Py_INCREF(self);
}
else
{
self = PyObject_NEW(TabPageObject, &TabPageType);
if (self == NULL)
return NULL;
self->tab = tab;
TAB_PYTHON_REF(tab) = self;
}
return (PyObject *)(self);
}
static void
TabPageDestructor(PyObject *self)
{
TabPageObject *this = (TabPageObject *)(self);
if (this->tab && this->tab != INVALID_TABPAGE_VALUE)
TAB_PYTHON_REF(this->tab) = NULL;
DESTRUCTOR_FINISH(self);
}
static PyObject *
TabPageAttr(TabPageObject *this, char *name)
{
if (strcmp(name, "windows") == 0)
return WinListNew(this);
else if (strcmp(name, "number") == 0)
return PyLong_FromLong((long) get_tab_number(this->tab));
else if (strcmp(name, "vars") == 0)
return DictionaryNew(this->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)
return WindowNew(curwin);
else
return WindowNew(this->tab->tp_curwin);
}
return NULL;
}
static PyObject *
TabPageRepr(PyObject *self)
{
static char repr[100];
TabPageObject *this = (TabPageObject *)(self);
if (this->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);
if (t == 0)
vim_snprintf(repr, 100, _("<tabpage object (unknown) at %p>"),
(self));
else
vim_snprintf(repr, 100, _("<tabpage %d>"), t - 1);
return PyString_FromString(repr);
}
}
static struct PyMethodDef TabPageMethods[] = {
/* name, function, calling, documentation */
{ NULL, NULL, 0, NULL }
};
/*
* Window list object
*/
static PyTypeObject TabListType;
static PySequenceMethods TabListAsSeq;
typedef struct
{
PyObject_HEAD
} TabListObject;
static PyInt
TabListLength(PyObject *self UNUSED)
{
tabpage_T *tp = first_tabpage;
PyInt n = 0;
while (tp != NULL)
{
++n;
tp = tp->tp_next;
}
return n;
}
static PyObject *
TabListItem(PyObject *self UNUSED, PyInt n)
{
tabpage_T *tp;
for (tp = first_tabpage; tp != NULL; tp = tp->tp_next, --n)
if (n == 0)
return TabPageNew(tp);
PyErr_SetString(PyExc_IndexError, _("no such tab page"));
return NULL;
}
/* Window object
*/
typedef struct
{
PyObject_HEAD
win_T *win;
} WindowObject;
static PyTypeObject WindowType;
static int
CheckWindow(WindowObject *this)
{
if (this->win == INVALID_WINDOW_VALUE)
{
PyErr_SetVim(_("attempt to refer to deleted window"));
return -1;
}
return 0;
}
static PyObject *
WindowNew(win_T *win)
{
/* We need to handle deletion of windows underneath us.
* If we add a "w_python*_ref" field to the win_T structure,
* then we can get at it in win_free() in vim. We then
* need to create only ONE Python object per window - if
* we try to create a second, just INCREF the existing one
* and return it. The (single) Python object referring to
* the window is stored in "w_python*_ref".
* On a win_free() we set the Python object's win_T* field
* to an invalid value. We trap all uses of a window
* object, and reject them if the win_T* field is invalid.
*
* Python2 and Python3 get different fields and different objects:
* w_python_ref and w_python3_ref fields respectively.
*/
WindowObject *self;
if (WIN_PYTHON_REF(win))
{
self = WIN_PYTHON_REF(win);
Py_INCREF(self);
}
else
{
self = PyObject_NEW(WindowObject, &WindowType);
if (self == NULL)
return NULL;
self->win = win;
WIN_PYTHON_REF(win) = self;
}
return (PyObject *)(self);
}
static void
WindowDestructor(PyObject *self)
{
WindowObject *this = (WindowObject *)(self);
if (this->win && this->win != INVALID_WINDOW_VALUE)
WIN_PYTHON_REF(this->win) = NULL;
DESTRUCTOR_FINISH(self);
}
static PyObject *
WindowAttr(WindowObject *this, char *name)
{
if (strcmp(name, "buffer") == 0)
return (PyObject *)BufferNew(this->win->w_buffer);
else if (strcmp(name, "cursor") == 0)
{
pos_T *pos = &this->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));
#ifdef FEAT_WINDOWS
else if (strcmp(name, "row") == 0)
return PyLong_FromLong((long)(this->win->w_winrow));
#endif
#ifdef FEAT_VERTSPLIT
else if (strcmp(name, "width") == 0)
return PyLong_FromLong((long)(W_WIDTH(this->win)));
else if (strcmp(name, "col") == 0)
return PyLong_FromLong((long)(W_WINCOL(this->win)));
#endif
else if (strcmp(name, "vars") == 0)
return DictionaryNew(this->win->w_vars);
else if (strcmp(name, "options") == 0)
return OptionsNew(SREQ_WIN, this->win, (checkfun) CheckWindow,
(PyObject *) this);
else if (strcmp(name, "number") == 0)
return PyLong_FromLong((long) get_win_number(this->win, firstwin));
else if (strcmp(name,"__members__") == 0)
return Py_BuildValue("[ssssssss]", "buffer", "cursor", "height", "vars",
"options", "number", "row", "col");
else
return NULL;
}
static int
WindowSetattr(PyObject *self, char *name, PyObject *val)
{
WindowObject *this = (WindowObject *)(self);
if (CheckWindow(this))
return -1;
if (strcmp(name, "buffer") == 0)
{
PyErr_SetString(PyExc_TypeError, _("readonly attribute"));
return -1;
}
else if (strcmp(name, "cursor") == 0)
{
long lnum;
long col;
if (!PyArg_Parse(val, "(ll)", &lnum, &col))
return -1;
if (lnum <= 0 || lnum > this->win->w_buffer->b_ml.ml_line_count)
{
PyErr_SetVim(_("cursor position outside buffer"));
return -1;
}
/* Check for keyboard interrupts */
if (VimErrorCheck())
return -1;
this->win->w_cursor.lnum = lnum;
this->win->w_cursor.col = col;
#ifdef FEAT_VIRTUALEDIT
this->win->w_cursor.coladd = 0;
#endif
/* When column is out of range silently correct it. */
check_cursor_col_win(this->win);
update_screen(VALID);
return 0;
}
else if (strcmp(name, "height") == 0)
{
int height;
win_T *savewin;
if (!PyArg_Parse(val, "i", &height))
return -1;
#ifdef FEAT_GUI
need_mouse_correct = TRUE;
#endif
savewin = curwin;
curwin = this->win;
win_setheight(height);
curwin = savewin;
/* Check for keyboard interrupts */
if (VimErrorCheck())
return -1;
return 0;
}
#ifdef FEAT_VERTSPLIT
else if (strcmp(name, "width") == 0)
{
int width;
win_T *savewin;
if (!PyArg_Parse(val, "i", &width))
return -1;
#ifdef FEAT_GUI
need_mouse_correct = TRUE;
#endif
savewin = curwin;
curwin = this->win;
win_setwidth(width);
curwin = savewin;
/* Check for keyboard interrupts */
if (VimErrorCheck())
return -1;
return 0;
}
#endif
else
{
PyErr_SetString(PyExc_AttributeError, name);
return -1;
}
}
static PyObject *
WindowRepr(PyObject *self)
{
static char repr[100];
WindowObject *this = (WindowObject *)(self);
if (this->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);
if (w == 0)
vim_snprintf(repr, 100, _("<window object (unknown) at %p>"),
(self));
else
vim_snprintf(repr, 100, _("<window %d>"), w - 1);
return PyString_FromString(repr);
}
}
static struct PyMethodDef WindowMethods[] = {
/* name, function, calling, documentation */
{ NULL, NULL, 0, NULL }
};
/*
* Window list object
*/
static PyTypeObject WinListType;
static PySequenceMethods WinListAsSeq;
typedef struct
{
PyObject_HEAD
TabPageObject *tabObject;
} WinListObject;
static PyObject *
WinListNew(TabPageObject *tabObject)
{
WinListObject *self;
self = PyObject_NEW(WinListObject, &WinListType);
self->tabObject = tabObject;
Py_INCREF(tabObject);
return (PyObject *)(self);
}
static void
WinListDestructor(PyObject *self)
{
TabPageObject *tabObject = ((WinListObject *)(self))->tabObject;
if (tabObject)
Py_DECREF((PyObject *)(tabObject));
DESTRUCTOR_FINISH(self);
}
static win_T *
get_firstwin(WinListObject *this)
{
if (this->tabObject)
{
if (CheckTabPage(this->tabObject))
return NULL;
/* For current tab window.c does not bother to set or update tp_firstwin
*/
else if (this->tabObject->tab == curtab)
return firstwin;
else
return this->tabObject->tab->tp_firstwin;
}
else
return firstwin;
}
static PyInt
WinListLength(PyObject *self)
{
win_T *w;
PyInt n = 0;
if (!(w = get_firstwin((WinListObject *)(self))))
return -1;
while (w != NULL)
{
++n;
w = W_NEXT(w);
}
return n;
}
static PyObject *
WinListItem(PyObject *self, PyInt n)
{
win_T *w;
if (!(w = get_firstwin((WinListObject *)(self))))
return NULL;
for (; w != NULL; w = W_NEXT(w), --n)
if (n == 0)
return WindowNew(w);
PyErr_SetString(PyExc_IndexError, _("no such window"));
return NULL;
}
/* Convert a Python string into a Vim line.
*
* The result is in allocated memory. All internal nulls are replaced by
* newline characters. It is an error for the string to contain newline
* characters.
*
* On errors, the Python exception data is set, and NULL is returned.
*/
static char *
StringToLine(PyObject *obj)
{
const char *str;
char *save;
PyObject *bytes;
PyInt len;
PyInt i;
char *p;
if (obj == NULL || !PyString_Check(obj))
{
PyErr_BadArgument();
return NULL;
}
bytes = PyString_AsBytes(obj); /* for Python 2 this does nothing */
str = PyString_AsString(bytes);
len = PyString_Size(bytes);
/*
* Error checking: String must not contain newlines, as we
* are replacing a single line, and we must replace it with
* a single line.
* A trailing newline is removed, so that append(f.readlines()) works.
*/
p = memchr(str, '\n', len);
if (p != NULL)
{
if (p == str + len - 1)
--len;
else
{
PyErr_SetVim(_("string cannot contain newlines"));
return NULL;
}
}
/* Create a copy of the string, with internal nulls replaced by
* newline characters, as is the vim convention.
*/
save = (char *)alloc((unsigned)(len+1));
if (save == NULL)
{
PyErr_NoMemory();
return NULL;
}
for (i = 0; i < len; ++i)
{
if (str[i] == '\0')
save[i] = '\n';
else
save[i] = str[i];
}
save[i] = '\0';
PyString_FreeBytes(bytes); /* Python 2 does nothing here */
return save;
}
/* Get a line from the specified buffer. The line number is
* in Vim format (1-based). The line is returned as a Python
* string object.
*/
static PyObject *
GetBufferLine(buf_T *buf, PyInt n)
{
return LineToString((char *)ml_get_buf(buf, (linenr_T)n, FALSE));
}
/* Get a list of lines from the specified buffer. The line numbers
* are in Vim format (1-based). The range is from lo up to, but not
* including, hi. The list is returned as a Python list of string objects.
*/
static PyObject *
GetBufferLineList(buf_T *buf, PyInt lo, PyInt hi)
{
PyInt i;
PyInt n = hi - lo;
PyObject *list = PyList_New(n);
if (list == NULL)
return NULL;
for (i = 0; i < n; ++i)
{
PyObject *str = LineToString((char *)ml_get_buf(buf, (linenr_T)(lo+i), FALSE));
/* Error check - was the Python string creation OK? */
if (str == NULL)
{
Py_DECREF(list);
return NULL;
}
/* Set the list item */
if (PyList_SetItem(list, i, str))
{
Py_DECREF(str);
Py_DECREF(list);
return NULL;
}
}
/* The ownership of the Python list is passed to the caller (ie,
* the caller should Py_DECREF() the object when it is finished
* with it).
*/
return list;
}
/*
* Check if deleting lines made the cursor position invalid.
* Changed the lines from "lo" to "hi" and added "extra" lines (negative if
* deleted).
*/
static void
py_fix_cursor(linenr_T lo, linenr_T hi, linenr_T extra)
{
if (curwin->w_cursor.lnum >= lo)
{
/* Adjust the cursor position if it's in/after the changed
* lines. */
if (curwin->w_cursor.lnum >= hi)
{
curwin->w_cursor.lnum += extra;
check_cursor_col();
}
else if (extra < 0)
{
curwin->w_cursor.lnum = lo;
check_cursor();
}
else
check_cursor_col();
changed_cline_bef_curs();
}
invalidate_botline();
}
/*
* Replace a line in the specified buffer. The line number is
* in Vim format (1-based). The replacement line is given as
* a Python string object. The object is checked for validity
* and correct format. Errors are returned as a value of FAIL.
* The return value is OK on success.
* If OK is returned and len_change is not NULL, *len_change
* is set to the change in the buffer length.
*/
static int
SetBufferLine(buf_T *buf, PyInt n, PyObject *line, PyInt *len_change)
{
/* First of all, we check the type of the supplied Python object.
* There are three cases:
* 1. NULL, or None - this is a deletion.
* 2. A string - this is a replacement.
* 3. Anything else - this is an error.
*/
if (line == Py_None || line == NULL)
{
buf_T *savebuf = curbuf;
PyErr_Clear();
curbuf = buf;
if (u_savedel((linenr_T)n, 1L) == FAIL)
PyErr_SetVim(_("cannot save undo information"));
else if (ml_delete((linenr_T)n, FALSE) == FAIL)
PyErr_SetVim(_("cannot delete line"));
else
{
if (buf == curwin->w_buffer)
py_fix_cursor((linenr_T)n, (linenr_T)n + 1, (linenr_T)-1);
deleted_lines_mark((linenr_T)n, 1L);
}
curbuf = savebuf;
if (PyErr_Occurred() || VimErrorCheck())
return FAIL;
if (len_change)
*len_change = -1;
return OK;
}
else if (PyString_Check(line))
{
char *save = StringToLine(line);
buf_T *savebuf = curbuf;
if (save == NULL)
return FAIL;
/* We do not need to free "save" if ml_replace() consumes it. */
PyErr_Clear();
curbuf = buf;
if (u_savesub((linenr_T)n) == FAIL)
{
PyErr_SetVim(_("cannot save undo information"));
vim_free(save);
}
else if (ml_replace((linenr_T)n, (char_u *)save, FALSE) == FAIL)
{
PyErr_SetVim(_("cannot replace line"));
vim_free(save);
}
else
changed_bytes((linenr_T)n, 0);
curbuf = savebuf;
/* Check that the cursor is not beyond the end of the line now. */
if (buf == curwin->w_buffer)
check_cursor_col();
if (PyErr_Occurred() || VimErrorCheck())
return FAIL;
if (len_change)
*len_change = 0;
return OK;
}
else
{
PyErr_BadArgument();
return FAIL;
}
}
/* Replace a range of lines in the specified buffer. The line numbers are in
* Vim format (1-based). The range is from lo up to, but not including, hi.
* The replacement lines are given as a Python list of string objects. The
* list is checked for validity and correct format. Errors are returned as a
* value of FAIL. The return value is OK on success.
* If OK is returned and len_change is not NULL, *len_change
* is set to the change in the buffer length.
*/
static int
SetBufferLineList(buf_T *buf, PyInt lo, PyInt hi, PyObject *list, PyInt *len_change)
{
/* First of all, we check the type of the supplied Python object.
* There are three cases:
* 1. NULL, or None - this is a deletion.
* 2. A list - this is a replacement.
* 3. Anything else - this is an error.
*/
if (list == Py_None || list == NULL)
{
PyInt i;
PyInt n = (int)(hi - lo);
buf_T *savebuf = curbuf;
PyErr_Clear();
curbuf = buf;
if (u_savedel((linenr_T)lo, (long)n) == FAIL)
PyErr_SetVim(_("cannot save undo information"));
else
{
for (i = 0; i < n; ++i)
{
if (ml_delete((linenr_T)lo, FALSE) == FAIL)
{
PyErr_SetVim(_("cannot delete line"));
break;
}
}
if (buf == curwin->w_buffer)
py_fix_cursor((linenr_T)lo, (linenr_T)hi, (linenr_T)-n);
deleted_lines_mark((linenr_T)lo, (long)i);
}
curbuf = savebuf;
if (PyErr_Occurred() || VimErrorCheck())
return FAIL;
if (len_change)
*len_change = -n;
return OK;
}
else if (PyList_Check(list))
{
PyInt i;
PyInt new_len = PyList_Size(list);
PyInt old_len = hi - lo;
PyInt extra = 0; /* lines added to text, can be negative */
char **array;
buf_T *savebuf;
if (new_len == 0) /* avoid allocating zero bytes */
array = NULL;
else
{
array = (char **)alloc((unsigned)(new_len * sizeof(char *)));
if (array == NULL)
{
PyErr_NoMemory();
return FAIL;
}
}
for (i = 0; i < new_len; ++i)
{
PyObject *line = PyList_GetItem(list, i);
array[i] = StringToLine(line);
if (array[i] == NULL)
{
while (i)
vim_free(array[--i]);
vim_free(array);
return FAIL;
}
}
savebuf = curbuf;
PyErr_Clear();
curbuf = buf;
if (u_save((linenr_T)(lo-1), (linenr_T)hi) == FAIL)
PyErr_SetVim(_("cannot save undo information"));
/* If the size of the range is reducing (ie, new_len < old_len) we
* need to delete some old_len. We do this at the start, by
* repeatedly deleting line "lo".
*/
if (!PyErr_Occurred())
{
for (i = 0; i < old_len - new_len; ++i)
if (ml_delete((linenr_T)lo, FALSE) == FAIL)
{
PyErr_SetVim(_("cannot delete line"));
break;
}
extra -= i;
}
/* For as long as possible, replace the existing old_len with the
* new old_len. This is a more efficient operation, as it requires
* less memory allocation and freeing.
*/
if (!PyErr_Occurred())
{
for (i = 0; i < old_len && i < new_len; ++i)
if (ml_replace((linenr_T)(lo+i), (char_u *)array[i], FALSE)
== FAIL)
{
PyErr_SetVim(_("cannot replace line"));
break;
}
}
else
i = 0;
/* Now we may need to insert the remaining new old_len. If we do, we
* must free the strings as we finish with them (we can't pass the
* responsibility to vim in this case).
*/
if (!PyErr_Occurred())
{
while (i < new_len)
{
if (ml_append((linenr_T)(lo + i - 1),
(char_u *)array[i], 0, FALSE) == FAIL)
{
PyErr_SetVim(_("cannot insert line"));
break;
}
vim_free(array[i]);
++i;
++extra;
}
}
/* Free any left-over old_len, as a result of an error */
while (i < new_len)
{
vim_free(array[i]);
++i;
}
/* Free the array of old_len. All of its contents have now
* been dealt with (either freed, or the responsibility passed
* to vim.
*/
vim_free(array);
/* Adjust marks. Invalidate any which lie in the
* changed range, and move any in the remainder of the buffer.
*/
mark_adjust((linenr_T)lo, (linenr_T)(hi - 1),
(long)MAXLNUM, (long)extra);
changed_lines((linenr_T)lo, 0, (linenr_T)hi, (long)extra);
if (buf == curwin->w_buffer)
py_fix_cursor((linenr_T)lo, (linenr_T)hi, (linenr_T)extra);
curbuf = savebuf;
if (PyErr_Occurred() || VimErrorCheck())
return FAIL;
if (len_change)
*len_change = new_len - old_len;
return OK;
}
else
{
PyErr_BadArgument();
return FAIL;
}
}
/* Insert a number of lines into the specified buffer after the specified line.
* The line number is in Vim format (1-based). The lines to be inserted are
* given as a Python list of string objects or as a single string. The lines
* to be added are checked for validity and correct format. Errors are
* returned as a value of FAIL. The return value is OK on success.
* If OK is returned and len_change is not NULL, *len_change
* is set to the change in the buffer length.
*/
static int
InsertBufferLines(buf_T *buf, PyInt n, PyObject *lines, PyInt *len_change)
{
/* First of all, we check the type of the supplied Python object.
* It must be a string or a list, or the call is in error.
*/
if (PyString_Check(lines))
{
char *str = StringToLine(lines);
buf_T *savebuf;
if (str == NULL)
return FAIL;
savebuf = curbuf;
PyErr_Clear();
curbuf = buf;
if (u_save((linenr_T)n, (linenr_T)(n+1)) == FAIL)
PyErr_SetVim(_("cannot save undo information"));
else if (ml_append((linenr_T)n, (char_u *)str, 0, FALSE) == FAIL)
PyErr_SetVim(_("cannot insert line"));
else
appended_lines_mark((linenr_T)n, 1L);
vim_free(str);
curbuf = savebuf;
update_screen(VALID);
if (PyErr_Occurred() || VimErrorCheck())
return FAIL;
if (len_change)
*len_change = 1;
return OK;
}
else if (PyList_Check(lines))
{
PyInt i;
PyInt size = PyList_Size(lines);
char **array;
buf_T *savebuf;
array = (char **)alloc((unsigned)(size * sizeof(char *)));
if (array == NULL)
{
PyErr_NoMemory();
return FAIL;
}
for (i = 0; i < size; ++i)
{
PyObject *line = PyList_GetItem(lines, i);
array[i] = StringToLine(line);
if (array[i] == NULL)
{
while (i)
vim_free(array[--i]);
vim_free(array);
return FAIL;
}
}
savebuf = curbuf;
PyErr_Clear();
curbuf = buf;
if (u_save((linenr_T)n, (linenr_T)(n + 1)) == FAIL)
PyErr_SetVim(_("cannot save undo information"));
else
{
for (i = 0; i < size; ++i)
{
if (ml_append((linenr_T)(n + i),
(char_u *)array[i], 0, FALSE) == FAIL)
{
PyErr_SetVim(_("cannot insert line"));
/* Free the rest of the lines */
while (i < size)
vim_free(array[i++]);
break;
}
vim_free(array[i]);
}
if (i > 0)
appended_lines_mark((linenr_T)n, (long)i);
}
/* Free the array of lines. All of its contents have now
* been freed.
*/
vim_free(array);
curbuf = savebuf;
update_screen(VALID);
if (PyErr_Occurred() || VimErrorCheck())
return FAIL;
if (len_change)
*len_change = size;
return OK;
}
else
{
PyErr_BadArgument();
return FAIL;
}
}
/*
* Common routines for buffers and line ranges
* -------------------------------------------
*/
typedef struct
{
PyObject_HEAD
buf_T *buf;
} BufferObject;
static int
CheckBuffer(BufferObject *this)
{
if (this->buf == INVALID_BUFFER_VALUE)
{
PyErr_SetVim(_("attempt to refer to deleted buffer"));
return -1;
}
return 0;
}
static PyObject *
RBItem(BufferObject *self, PyInt n, PyInt start, PyInt end)
{
if (CheckBuffer(self))
return NULL;
if (end == -1)
end = self->buf->b_ml.ml_line_count;
if (n < 0)
n += end - start + 1;
if (n < 0 || n > end - start)
{
PyErr_SetString(PyExc_IndexError, _("line number out of range"));
return NULL;
}
return GetBufferLine(self->buf, n+start);
}
static PyObject *
RBSlice(BufferObject *self, PyInt lo, PyInt hi, PyInt start, PyInt end)
{
PyInt size;
if (CheckBuffer(self))
return NULL;
if (end == -1)
end = self->buf->b_ml.ml_line_count;
size = end - start + 1;
if (lo < 0)
lo = 0;
else if (lo > size)
lo = size;
if (hi < 0)
hi = 0;
if (hi < lo)
hi = lo;
else if (hi > size)
hi = size;
return GetBufferLineList(self->buf, lo+start, hi+start);
}
static PyInt
RBAsItem(BufferObject *self, PyInt n, PyObject *val, PyInt start, PyInt end, PyInt *new_end)
{
PyInt len_change;
if (CheckBuffer(self))
return -1;
if (end == -1)
end = self->buf->b_ml.ml_line_count;
if (n < 0)
n += end - start + 1;
if (n < 0 || n > end - start)
{
PyErr_SetString(PyExc_IndexError, _("line number out of range"));
return -1;
}
if (SetBufferLine(self->buf, n+start, val, &len_change) == FAIL)
return -1;
if (new_end)
*new_end = end + len_change;
return 0;
}
static PyInt
RBAsSlice(BufferObject *self, PyInt lo, PyInt hi, PyObject *val, PyInt start, PyInt end, PyInt *new_end)
{
PyInt size;
PyInt len_change;
/* Self must be a valid buffer */
if (CheckBuffer(self))
return -1;
if (end == -1)
end = self->buf->b_ml.ml_line_count;
/* Sort out the slice range */
size = end - start + 1;
if (lo < 0)
lo = 0;
else if (lo > size)
lo = size;
if (hi < 0)
hi = 0;
if (hi < lo)
hi = lo;
else if (hi > size)
hi = size;
if (SetBufferLineList(self->buf, lo + start, hi + start,
val, &len_change) == FAIL)
return -1;
if (new_end)
*new_end = end + len_change;
return 0;
}
static PyObject *
RBAppend(BufferObject *self, PyObject *args, PyInt start, PyInt end, PyInt *new_end)
{
PyObject *lines;
PyInt len_change;
PyInt max;
PyInt n;
if (CheckBuffer(self))
return NULL;
if (end == -1)
end = self->buf->b_ml.ml_line_count;
max = n = end - start + 1;
if (!PyArg_ParseTuple(args, "O|n", &lines, &n))
return NULL;
if (n < 0 || n > max)
{
PyErr_SetString(PyExc_IndexError, _("line number out of range"));
return NULL;
}
if (InsertBufferLines(self->buf, n + start - 1, lines, &len_change) == FAIL)
return NULL;
if (new_end)
*new_end = end + len_change;
Py_INCREF(Py_None);
return Py_None;
}
/* Range object
*/
static PyTypeObject RangeType;
static PySequenceMethods RangeAsSeq;
static PyMappingMethods RangeAsMapping;
typedef struct
{
PyObject_HEAD
BufferObject *buf;
PyInt start;
PyInt end;
} RangeObject;
static PyObject *
RangeNew(buf_T *buf, PyInt start, PyInt end)
{
BufferObject *bufr;
RangeObject *self;
self = PyObject_NEW(RangeObject, &RangeType);
if (self == NULL)
return NULL;
bufr = (BufferObject *)BufferNew(buf);
if (bufr == NULL)
{
Py_DECREF(self);
return NULL;
}
Py_INCREF(bufr);
self->buf = bufr;
self->start = start;
self->end = end;
return (PyObject *)(self);
}
static void
RangeDestructor(PyObject *self)
{
Py_DECREF(((RangeObject *)(self))->buf);
DESTRUCTOR_FINISH(self);
}
static PyInt
RangeLength(PyObject *self)
{
/* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */
if (CheckBuffer(((RangeObject *)(self))->buf))
return -1; /* ??? */
return (((RangeObject *)(self))->end - ((RangeObject *)(self))->start + 1);
}
static PyObject *
RangeItem(PyObject *self, PyInt n)
{
return RBItem(((RangeObject *)(self))->buf, n,
((RangeObject *)(self))->start,
((RangeObject *)(self))->end);
}
static PyObject *
RangeSlice(PyObject *self, PyInt lo, PyInt hi)
{
return RBSlice(((RangeObject *)(self))->buf, lo, hi,
((RangeObject *)(self))->start,
((RangeObject *)(self))->end);
}
static PyObject *
RangeAppend(PyObject *self, PyObject *args)
{
return RBAppend(((RangeObject *)(self))->buf, args,
((RangeObject *)(self))->start,
((RangeObject *)(self))->end,
&((RangeObject *)(self))->end);
}
static PyObject *
RangeRepr(PyObject *self)
{
static char repr[100];
RangeObject *this = (RangeObject *)(self);
if (this->buf->buf == INVALID_BUFFER_VALUE)
{
vim_snprintf(repr, 100, "<range object (for deleted buffer) at %p>",
(self));
return PyString_FromString(repr);
}
else
{
char *name = (char *)this->buf->buf->b_fname;
int len;
if (name == NULL)
name = "";
len = (int)strlen(name);
if (len > 45)
name = name + (45 - len);
vim_snprintf(repr, 100, "<range %s%s (%d:%d)>",
len > 45 ? "..." : "", name,
this->start, this->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 }
};
static PyTypeObject BufferType;
static PySequenceMethods BufferAsSeq;
static PyMappingMethods BufferAsMapping;
static PyObject *
BufferNew(buf_T *buf)
{
/* We need to handle deletion of buffers underneath us.
* If we add a "b_python*_ref" field to the buf_T structure,
* then we can get at it in buf_freeall() in vim. We then
* need to create only ONE Python object per buffer - if
* we try to create a second, just INCREF the existing one
* and return it. The (single) Python object referring to
* the buffer is stored in "b_python*_ref".
* Question: what to do on a buf_freeall(). We'll probably
* have to either delete the Python object (DECREF it to
* zero - a bad idea, as it leaves dangling refs!) or
* set the buf_T * value to an invalid value (-1?), which
* means we need checks in all access functions... Bah.
*
* Python2 and Python3 get different fields and different objects:
* b_python_ref and b_python3_ref fields respectively.
*/
BufferObject *self;
if (BUF_PYTHON_REF(buf) != NULL)
{
self = BUF_PYTHON_REF(buf);
Py_INCREF(self);
}
else
{
self = PyObject_NEW(BufferObject, &BufferType);
if (self == NULL)
return NULL;
self->buf = buf;
BUF_PYTHON_REF(buf) = self;
}
return (PyObject *)(self);
}
static void
BufferDestructor(PyObject *self)
{
BufferObject *this = (BufferObject *)(self);
if (this->buf && this->buf != INVALID_BUFFER_VALUE)
BUF_PYTHON_REF(this->buf) = NULL;
DESTRUCTOR_FINISH(self);
}
static PyInt
BufferLength(PyObject *self)
{
/* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */
if (CheckBuffer((BufferObject *)(self)))
return -1; /* ??? */
return (PyInt)(((BufferObject *)(self))->buf->b_ml.ml_line_count);
}
static PyObject *
BufferItem(PyObject *self, PyInt n)
{
return RBItem((BufferObject *)(self), n, 1, -1);
}
static PyObject *
BufferSlice(PyObject *self, PyInt lo, PyInt hi)
{
return RBSlice((BufferObject *)(self), lo, hi, 1, -1);
}
static PyObject *
BufferAttr(BufferObject *this, char *name)
{
if (strcmp(name, "name") == 0)
return Py_BuildValue("s", this->buf->b_ffname);
else if (strcmp(name, "number") == 0)
return Py_BuildValue(Py_ssize_t_fmt, this->buf->b_fnum);
else if (strcmp(name, "vars") == 0)
return DictionaryNew(this->buf->b_vars);
else if (strcmp(name, "options") == 0)
return OptionsNew(SREQ_BUF, this->buf, (checkfun) CheckBuffer,
(PyObject *) this);
else if (strcmp(name,"__members__") == 0)
return Py_BuildValue("[ssss]", "name", "number", "vars", "options");
else
return NULL;
}
static PyObject *
BufferAppend(PyObject *self, PyObject *args)
{
return RBAppend((BufferObject *)(self), args, 1, -1, NULL);
}
static PyObject *
BufferMark(PyObject *self, PyObject *args)
{
pos_T *posp;
char *pmark;
char mark;
buf_T *curbuf_save;
if (CheckBuffer((BufferObject *)(self)))
return NULL;
if (!PyArg_ParseTuple(args, "s", &pmark))
return NULL;
mark = *pmark;
curbuf_save = curbuf;
curbuf = ((BufferObject *)(self))->buf;
posp = getmark(mark, FALSE);
curbuf = curbuf_save;
if (posp == NULL)
{
PyErr_SetVim(_("invalid mark name"));
return NULL;
}
/* Check for keyboard interrupt */
if (VimErrorCheck())
return NULL;
if (posp->lnum <= 0)
{
/* Or raise an error? */
Py_INCREF(Py_None);
return Py_None;
}
return Py_BuildValue("(ll)", (long)(posp->lnum), (long)(posp->col));
}
static PyObject *
BufferRange(PyObject *self, PyObject *args)
{
PyInt start;
PyInt end;
if (CheckBuffer((BufferObject *)(self)))
return NULL;
if (!PyArg_ParseTuple(args, "nn", &start, &end))
return NULL;
return RangeNew(((BufferObject *)(self))->buf, start, end);
}
static PyObject *
BufferRepr(PyObject *self)
{
static char repr[100];
BufferObject *this = (BufferObject *)(self);
if (this->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;
PyInt len;
if (name == NULL)
name = "";
len = strlen(name);
if (len > 35)
name = name + (35 - len);
vim_snprintf(repr, 100, "<buffer %s%s>", len > 35 ? "..." : "", name);
return PyString_FromString(repr);
}
}
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" },
#if PY_VERSION_HEX >= 0x03000000
{"__dir__", BufferDir, 4, "List its attributes" },
#endif
{ NULL, NULL, 0, NULL }
};
/*
* Buffer list object - Implementation
*/
static PyTypeObject BufMapType;
typedef struct
{
PyObject_HEAD
} BufMapObject;
static PyInt
BufMapLength(PyObject *self UNUSED)
{
buf_T *b = firstbuf;
PyInt n = 0;
while (b)
{
++n;
b = b->b_next;
}
return n;
}
static PyObject *
BufMapItem(PyObject *self UNUSED, PyObject *keyObject)
{
buf_T *b;
int bnr;
#if PY_MAJOR_VERSION < 3
if (PyInt_Check(keyObject))
bnr = PyInt_AsLong(keyObject);
else
#endif
if (PyLong_Check(keyObject))
bnr = PyLong_AsLong(keyObject);
else
{
PyErr_SetString(PyExc_TypeError, _("key must be integer"));
return NULL;
}
b = buflist_findnr(bnr);
if (b)
return BufferNew(b);
else
{
PyErr_SetObject(PyExc_KeyError, keyObject);
return NULL;
}
}
static void
BufMapIterDestruct(PyObject *buffer)
{
/* Iteration was stopped before all buffers were processed */
if (buffer)
{
Py_DECREF(buffer);
}
}
static PyObject *
BufMapIterNext(PyObject **buffer)
{
PyObject *next;
PyObject *r;
if (!*buffer)
return NULL;
r = *buffer;
if (CheckBuffer((BufferObject *)(r)))
{
*buffer = NULL;
return NULL;
}
if (!((BufferObject *)(r))->buf->b_next)
next = NULL;
else if (!(next = BufferNew(((BufferObject *)(r))->buf->b_next)))
return NULL;
*buffer = next;
/* Do not increment reference: we no longer hold it (decref), but whoever on
* other side will hold (incref). Decref+incref = nothing.
*/
return r;
}
static PyObject *
BufMapIter(PyObject *self UNUSED)
{
PyObject *buffer;
buffer = BufferNew(firstbuf);
return IterNew(buffer,
(destructorfun) BufMapIterDestruct, (nextfun) BufMapIterNext);
}
static PyMappingMethods BufMapAsMapping = {
(lenfunc) BufMapLength,
(binaryfunc) BufMapItem,
(objobjargproc) 0,
};
/* Current items object
*/
static PyObject *
CurrentGetattr(PyObject *self UNUSED, char *name)
{
if (strcmp(name, "buffer") == 0)
return (PyObject *)BufferNew(curbuf);
else if (strcmp(name, "window") == 0)
return (PyObject *)WindowNew(curwin);
else if (strcmp(name, "tabpage") == 0)
return (PyObject *)TabPageNew(curtab);
else if (strcmp(name, "line") == 0)
return GetBufferLine(curbuf, (PyInt)curwin->w_cursor.lnum);
else if (strcmp(name, "range") == 0)
return RangeNew(curbuf, RangeStart, RangeEnd);
else if (strcmp(name,"__members__") == 0)
return Py_BuildValue("[sssss]", "buffer", "window", "line", "range",
"tabpage");
else
{
PyErr_SetString(PyExc_AttributeError, name);
return NULL;
}
}
static int
CurrentSetattr(PyObject *self UNUSED, char *name, PyObject *value)
{
if (strcmp(name, "line") == 0)
{
if (SetBufferLine(curbuf, (PyInt)curwin->w_cursor.lnum, value, NULL) == FAIL)
return -1;
return 0;
}
else if (strcmp(name, "buffer") == 0)
{
int count;
if (value->ob_type != &BufferType)
{
PyErr_SetString(PyExc_TypeError, _("expected vim.buffer object"));
return -1;
}
if (CheckBuffer((BufferObject *)(value)))
return -1;
count = ((BufferObject *)(value))->buf->b_fnum;
if (do_buffer(DOBUF_GOTO, DOBUF_FIRST, FORWARD, count, 0) == FAIL)
{
PyErr_SetVim(_("failed to switch to given buffer"));
return -1;
}
return 0;
}
else if (strcmp(name, "window") == 0)
{
int count;
if (value->ob_type != &WindowType)
{
PyErr_SetString(PyExc_TypeError, _("expected vim.window object"));
return -1;
}
if (CheckWindow((WindowObject *)(value)))
return -1;
count = get_win_number(((WindowObject *)(value))->win, firstwin);
if (!count)
{
PyErr_SetString(PyExc_ValueError,
_("failed to find window in the current tab page"));
return -1;
}
win_goto(((WindowObject *)(value))->win);
if (((WindowObject *)(value))->win != curwin)
{
PyErr_SetString(PyExc_RuntimeError,
_("did not switch to the specified window"));
return -1;
}
return 0;
}
else if (strcmp(name, "tabpage") == 0)
{
if (value->ob_type != &TabPageType)
{
PyErr_SetString(PyExc_TypeError, _("expected vim.tabpage object"));
return -1;
}
if (CheckTabPage((TabPageObject *)(value)))
return -1;
goto_tabpage_tp(((TabPageObject *)(value))->tab, TRUE, TRUE);
if (((TabPageObject *)(value))->tab != curtab)
{
PyErr_SetString(PyExc_RuntimeError,
_("did not switch to the specified tab page"));
return -1;
}
return 0;
}
else
{
PyErr_SetString(PyExc_AttributeError, name);
return -1;
}
}
static void
set_ref_in_py(const int copyID)
{
pylinkedlist_T *cur;
dict_T *dd;
list_T *ll;
if (lastdict != NULL)
for(cur = lastdict ; cur != NULL ; cur = cur->pll_prev)
{
dd = ((DictionaryObject *) (cur->pll_obj))->dict;
if (dd->dv_copyID != copyID)
{
dd->dv_copyID = copyID;
set_ref_in_ht(&dd->dv_hashtab, copyID);
}
}
if (lastlist != NULL)
for(cur = lastlist ; cur != NULL ; cur = cur->pll_prev)
{
ll = ((ListObject *) (cur->pll_obj))->list;
if (ll->lv_copyID != copyID)
{
ll->lv_copyID = copyID;
set_ref_in_list(ll, copyID);
}
}
}
static int
set_string_copy(char_u *str, typval_T *tv)
{
tv->vval.v_string = vim_strsave(str);
if (tv->vval.v_string == NULL)
{
PyErr_NoMemory();
return -1;
}
return 0;
}
static int
pydict_to_tv(PyObject *obj, typval_T *tv, PyObject *lookupDict)
{
dict_T *d;
char_u *key;
dictitem_T *di;
PyObject *keyObject;
PyObject *valObject;
Py_ssize_t iter = 0;
d = dict_alloc();
if (d == NULL)
{
PyErr_NoMemory();
return -1;
}
tv->v_type = VAR_DICT;
tv->vval.v_dict = d;
while (PyDict_Next(obj, &iter, &keyObject, &valObject))
{
DICTKEY_DECL
if (keyObject == NULL)
return -1;
if (valObject == NULL)
return -1;
DICTKEY_GET_NOTEMPTY(-1)
di = dictitem_alloc(key);
DICTKEY_UNREF
if (di == NULL)
{
PyErr_NoMemory();
return -1;
}
di->di_tv.v_lock = 0;
if (_ConvertFromPyObject(valObject, &di->di_tv, lookupDict) == -1)
{
vim_free(di);
return -1;
}
if (dict_add(d, di) == FAIL)
{
vim_free(di);
PyErr_SetVim(_("failed to add key to dictionary"));
return -1;
}
}
return 0;
}
static int
pymap_to_tv(PyObject *obj, typval_T *tv, PyObject *lookupDict)
{
dict_T *d;
char_u *key;
dictitem_T *di;
PyObject *list;
PyObject *litem;
PyObject *keyObject;
PyObject *valObject;
Py_ssize_t lsize;
d = dict_alloc();
if (d == NULL)
{
PyErr_NoMemory();
return -1;
}
tv->v_type = VAR_DICT;
tv->vval.v_dict = d;
list = PyMapping_Items(obj);
if (list == NULL)
return -1;
lsize = PyList_Size(list);
while (lsize--)
{
DICTKEY_DECL
litem = PyList_GetItem(list, lsize);
if (litem == NULL)
{
Py_DECREF(list);
return -1;
}
keyObject = PyTuple_GetItem(litem, 0);
if (keyObject == NULL)
{
Py_DECREF(list);
Py_DECREF(litem);
return -1;
}
DICTKEY_GET_NOTEMPTY(-1)
valObject = PyTuple_GetItem(litem, 1);
if (valObject == NULL)
{
Py_DECREF(list);
Py_DECREF(litem);
return -1;
}
di = dictitem_alloc(key);
DICTKEY_UNREF
if (di == NULL)
{
Py_DECREF(list);
Py_DECREF(litem);
PyErr_NoMemory();
return -1;
}
di->di_tv.v_lock = 0;
if (_ConvertFromPyObject(valObject, &di->di_tv, lookupDict) == -1)
{
vim_free(di);
Py_DECREF(list);
Py_DECREF(litem);
return -1;
}
if (dict_add(d, di) == FAIL)
{
vim_free(di);
Py_DECREF(list);
Py_DECREF(litem);
PyErr_SetVim(_("failed to add key to dictionary"));
return -1;
}
Py_DECREF(litem);
}
Py_DECREF(list);
return 0;
}
static int
pyseq_to_tv(PyObject *obj, typval_T *tv, PyObject *lookupDict)
{
list_T *l;
l = list_alloc();
if (l == NULL)
{
PyErr_NoMemory();
return -1;
}
tv->v_type = VAR_LIST;
tv->vval.v_list = l;
if (list_py_concat(l, obj, lookupDict) == -1)
return -1;
return 0;
}
static int
pyiter_to_tv(PyObject *obj, typval_T *tv, PyObject *lookupDict)
{
PyObject *iterator = PyObject_GetIter(obj);
PyObject *item;
list_T *l;
listitem_T *li;
l = list_alloc();
if (l == NULL)
{
PyErr_NoMemory();
return -1;
}
tv->vval.v_list = l;
tv->v_type = VAR_LIST;
if (iterator == NULL)
return -1;
while ((item = PyIter_Next(obj)))
{
li = listitem_alloc();
if (li == NULL)
{
PyErr_NoMemory();
return -1;
}
li->li_tv.v_lock = 0;
if (_ConvertFromPyObject(item, &li->li_tv, lookupDict) == -1)
return -1;
list_append(l, li);
Py_DECREF(item);
}
Py_DECREF(iterator);
return 0;
}
typedef int (*pytotvfunc)(PyObject *, typval_T *, PyObject *);
static int
convert_dl(PyObject *obj, typval_T *tv,
pytotvfunc py_to_tv, PyObject *lookupDict)
{
PyObject *capsule;
char hexBuf[sizeof(void *) * 2 + 3];
sprintf(hexBuf, "%p", obj);
# ifdef PY_USE_CAPSULE
capsule = PyDict_GetItemString(lookupDict, hexBuf);
# else
capsule = (PyObject *)PyDict_GetItemString(lookupDict, hexBuf);
# endif
if (capsule == NULL)
{
# ifdef PY_USE_CAPSULE
capsule = PyCapsule_New(tv, NULL, NULL);
# else
capsule = PyCObject_FromVoidPtr(tv, NULL);
# endif
PyDict_SetItemString(lookupDict, hexBuf, capsule);
Py_DECREF(capsule);
if (py_to_tv(obj, tv, lookupDict) == -1)
{
tv->v_type = VAR_UNKNOWN;
return -1;
}
/* As we are not using copy_tv which increments reference count we must
* do it ourself. */
switch(tv->v_type)
{
case VAR_DICT: ++tv->vval.v_dict->dv_refcount; break;
case VAR_LIST: ++tv->vval.v_list->lv_refcount; break;
}
}
else
{
typval_T *v;
# ifdef PY_USE_CAPSULE
v = PyCapsule_GetPointer(capsule, NULL);
# else
v = PyCObject_AsVoidPtr(capsule);
# endif
copy_tv(v, tv);
}
return 0;
}
static int
ConvertFromPyObject(PyObject *obj, typval_T *tv)
{
PyObject *lookup_dict;
int r;
lookup_dict = PyDict_New();
r = _ConvertFromPyObject(obj, tv, lookup_dict);
Py_DECREF(lookup_dict);
return r;
}
static int
_ConvertFromPyObject(PyObject *obj, typval_T *tv, PyObject *lookupDict)
{
if (obj->ob_type == &DictionaryType)
{
tv->v_type = VAR_DICT;
tv->vval.v_dict = (((DictionaryObject *)(obj))->dict);
++tv->vval.v_dict->dv_refcount;
}
else if (obj->ob_type == &ListType)
{
tv->v_type = VAR_LIST;
tv->vval.v_list = (((ListObject *)(obj))->list);
++tv->vval.v_list->lv_refcount;
}
else if (obj->ob_type == &FunctionType)
{
if (set_string_copy(((FunctionObject *) (obj))->name, tv) == -1)
return -1;
tv->v_type = VAR_FUNC;
func_ref(tv->vval.v_string);
}
else if (PyBytes_Check(obj))
{
char_u *result;
if (PyString_AsStringAndSize(obj, (char **) &result, NULL) == -1)
return -1;
if (result == NULL)
return -1;
if (set_string_copy(result, tv) == -1)
return -1;
tv->v_type = VAR_STRING;
}
else if (PyUnicode_Check(obj))
{
PyObject *bytes;
char_u *result;
bytes = PyUnicode_AsEncodedString(obj, (char *)ENC_OPT, NULL);
if (bytes == NULL)
return -1;
if(PyString_AsStringAndSize(bytes, (char **) &result, NULL) == -1)
return -1;
if (result == NULL)
return -1;
if (set_string_copy(result, tv) == -1)
{
Py_XDECREF(bytes);
return -1;
}
Py_XDECREF(bytes);
tv->v_type = VAR_STRING;
}
#if PY_MAJOR_VERSION < 3
else if (PyInt_Check(obj))
{
tv->v_type = VAR_NUMBER;
tv->vval.v_number = (varnumber_T) PyInt_AsLong(obj);
}
#endif
else if (PyLong_Check(obj))
{
tv->v_type = VAR_NUMBER;
tv->vval.v_number = (varnumber_T) PyLong_AsLong(obj);
}
else if (PyDict_Check(obj))
return convert_dl(obj, tv, pydict_to_tv, lookupDict);
#ifdef FEAT_FLOAT
else if (PyFloat_Check(obj))
{
tv->v_type = VAR_FLOAT;
tv->vval.v_float = (float_T) PyFloat_AsDouble(obj);
}
#endif
else if (PyIter_Check(obj))
return convert_dl(obj, tv, pyiter_to_tv, lookupDict);
else if (PySequence_Check(obj))
return convert_dl(obj, tv, pyseq_to_tv, lookupDict);
else if (PyMapping_Check(obj))
return convert_dl(obj, tv, pymap_to_tv, lookupDict);
else
{
PyErr_SetString(PyExc_TypeError,
_("unable to convert to vim structure"));
return -1;
}
return 0;
}
static PyObject *
ConvertToPyObject(typval_T *tv)
{
if (tv == NULL)
{
PyErr_SetVim(_("NULL reference passed"));
return NULL;
}
switch (tv->v_type)
{
case VAR_STRING:
return PyBytes_FromString(tv->vval.v_string == NULL
? "" : (char *)tv->vval.v_string);
case VAR_NUMBER:
return PyLong_FromLong((long) tv->vval.v_number);
#ifdef FEAT_FLOAT
case VAR_FLOAT:
return PyFloat_FromDouble((double) tv->vval.v_float);
#endif
case VAR_LIST:
return ListNew(tv->vval.v_list);
case VAR_DICT:
return DictionaryNew(tv->vval.v_dict);
case VAR_FUNC:
return FunctionNew(tv->vval.v_string == NULL
? (char_u *)"" : tv->vval.v_string);
case VAR_UNKNOWN:
Py_INCREF(Py_None);
return Py_None;
default:
PyErr_SetVim(_("internal error: invalid value type"));
return NULL;
}
}
typedef struct
{
PyObject_HEAD
} CurrentObject;
static PyTypeObject CurrentType;
static void
init_structs(void)
{
vim_memset(&OutputType, 0, sizeof(OutputType));
OutputType.tp_name = "vim.message";
OutputType.tp_basicsize = sizeof(OutputObject);
OutputType.tp_flags = Py_TPFLAGS_DEFAULT;
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_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;
#endif
vim_memset(&IterType, 0, sizeof(IterType));
IterType.tp_name = "vim.iter";
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;
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_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_alloc = call_PyType_GenericAlloc;
BufferType.tp_new = call_PyType_GenericNew;
BufferType.tp_free = call_PyObject_Free;
#else
BufferType.tp_getattr = 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_flags = Py_TPFLAGS_DEFAULT;
WindowType.tp_doc = "vim Window object";
WindowType.tp_methods = WindowMethods;
#if PY_MAJOR_VERSION >= 3
WindowType.tp_getattro = WindowGetattro;
WindowType.tp_setattro = 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;
#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_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_alloc = call_PyType_GenericAlloc;
TabPageType.tp_new = call_PyType_GenericNew;
TabPageType.tp_free = call_PyObject_Free;
#else
TabPageType.tp_getattr = TabPageGetattr;
#endif
vim_memset(&BufMapType, 0, sizeof(BufMapType));
BufMapType.tp_name = "vim.bufferlist";
BufMapType.tp_basicsize = sizeof(BufMapObject);
BufMapType.tp_as_mapping = &BufMapAsMapping;
BufMapType.tp_flags = Py_TPFLAGS_DEFAULT;
BufMapType.tp_iter = BufMapIter;
BufferType.tp_doc = "vim buffer list";
vim_memset(&WinListType, 0, sizeof(WinListType));
WinListType.tp_name = "vim.windowlist";
WinListType.tp_basicsize = sizeof(WinListType);
WinListType.tp_as_sequence = &WinListAsSeq;
WinListType.tp_flags = Py_TPFLAGS_DEFAULT;
WinListType.tp_doc = "vim window list";
WinListType.tp_dealloc = WinListDestructor;
vim_memset(&TabListType, 0, sizeof(TabListType));
TabListType.tp_name = "vim.tabpagelist";
TabListType.tp_basicsize = sizeof(TabListType);
TabListType.tp_as_sequence = &TabListAsSeq;
TabListType.tp_flags = Py_TPFLAGS_DEFAULT;
TabListType.tp_doc = "vim tab page list";
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_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_alloc = call_PyType_GenericAlloc;
RangeType.tp_new = call_PyType_GenericNew;
RangeType.tp_free = call_PyObject_Free;
#else
RangeType.tp_getattr = RangeGetattr;
#endif
vim_memset(&CurrentType, 0, sizeof(CurrentType));
CurrentType.tp_name = "vim.currentdata";
CurrentType.tp_basicsize = sizeof(CurrentObject);
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;
#else
CurrentType.tp_getattr = CurrentGetattr;
CurrentType.tp_setattr = CurrentSetattr;
#endif
vim_memset(&DictionaryType, 0, sizeof(DictionaryType));
DictionaryType.tp_name = "vim.dictionary";
DictionaryType.tp_basicsize = sizeof(DictionaryObject);
DictionaryType.tp_dealloc = 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;
#else
DictionaryType.tp_getattr = DictionaryGetattr;
DictionaryType.tp_setattr = DictionarySetattr;
#endif
vim_memset(&ListType, 0, sizeof(ListType));
ListType.tp_name = "vim.list";
ListType.tp_dealloc = 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;
#if PY_MAJOR_VERSION >= 3
ListType.tp_getattro = ListGetattro;
ListType.tp_setattro = ListSetattro;
#else
ListType.tp_getattr = ListGetattr;
ListType.tp_setattr = 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_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;
#else
FunctionType.tp_getattr = FunctionGetattr;
#endif
vim_memset(&OptionsType, 0, sizeof(OptionsType));
OptionsType.tp_name = "vim.options";
OptionsType.tp_basicsize = sizeof(OptionsObject);
OptionsType.tp_flags = Py_TPFLAGS_DEFAULT;
OptionsType.tp_doc = "object for manipulating options";
OptionsType.tp_as_mapping = &OptionsAsMapping;
OptionsType.tp_dealloc = OptionsDestructor;
#if PY_MAJOR_VERSION >= 3
vim_memset(&vimmodule, 0, sizeof(vimmodule));
vimmodule.m_name = "vim";
vimmodule.m_doc = "Vim Python interface\n";
vimmodule.m_size = -1;
vimmodule.m_methods = VimMethods;
#endif
}
View Git Blame Copy Permalink