};
/*
- * Buffer list object - Implementation
+ * Generic iterator object
*/
-static PyTypeObject BufMapType;
+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
-} BufMapObject;
+ void *cur;
+ nextfun next;
+ destructorfun destruct;
+} IterObject;
- static PyInt
-BufMapLength(PyObject *self UNUSED)
+ static PyObject *
+IterNew(void *start, destructorfun destruct, nextfun next)
{
- buf_T *b = firstbuf;
- PyInt n = 0;
+ IterObject *self;
- while (b)
- {
- ++n;
- b = b->b_next;
- }
+ self = PyObject_NEW(IterObject, &IterType);
+ self->cur = start;
+ self->next = next;
+ self->destruct = destruct;
- return n;
+ return (PyObject *)(self);
}
- static PyObject *
-BufMapItem(PyObject *self UNUSED, PyObject *keyObject)
+ static void
+IterDestructor(PyObject *self)
{
- buf_T *b;
- int bnr;
+ IterObject *this = (IterObject *)(self);
-#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_ValueError, _("key must be integer"));
- return NULL;
- }
+ this->destruct(this->cur);
- b = buflist_findnr(bnr);
+ DESTRUCTOR_FINISH(self);
+}
- if (b)
- return BufferNew(b);
- else
- {
- PyErr_SetString(PyExc_KeyError, _("no such buffer"));
- return NULL;
- }
+ static PyObject *
+IterNext(PyObject *self)
+{
+ IterObject *this = (IterObject *)(self);
+
+ return this->next(&this->cur);
}
-static PyMappingMethods BufMapAsMapping = {
- (lenfunc) BufMapLength,
- (binaryfunc) BufMapItem,
- (objobjargproc) 0,
-};
+ static PyObject *
+IterIter(PyObject *self)
+{
+ return self;
+}
typedef struct pylinkedlist_S {
struct pylinkedlist_S *pll_next;
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)
{
{ 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_ValueError, _("key must be integer"));
+ return NULL;
+ }
+
+ b = buflist_findnr(bnr);
+
+ if (b)
+ return BufferNew(b);
+ else
+ {
+ PyErr_SetString(PyExc_KeyError, _("no such buffer"));
+ 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
*/
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);
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));
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;
#endif
vim_memset(&FunctionType, 0, sizeof(FunctionType));
- FunctionType.tp_name = "vim.list";
+ FunctionType.tp_name = "vim.function";
FunctionType.tp_basicsize = sizeof(FunctionObject);
FunctionType.tp_dealloc = FunctionDestructor;
FunctionType.tp_call = FunctionCall;
: call RecVars(oname)
:endfor
:only
+:for buf in g:bufs[1:]
+: execute 'bwipeout!' buf
+:endfor
:"
:" Test buffer object
:vnew
# Should not happen in any case
cb.append('No exception for ' + expr)
EOF
+:"
+:" Test vim.buffers object
+:set hidden
+:edit a
+:buffer #
+:edit b
+:buffer #
+:edit c
+:buffer #
+py << EOF
+# Check GCing iterator that was not fully exhausted
+i = iter(vim.buffers)
+cb.append('i:' + str(next(i)))
+# and also check creating more then one iterator at a time
+i2 = iter(vim.buffers)
+cb.append('i2:' + str(next(i2)))
+cb.append('i:' + str(next(i)))
+# The following should trigger GC and not cause any problems
+del i
+del i2
+i3 = iter(vim.buffers)
+cb.append('i3:' + str(next(i3)))
+del i3
+
+prevnum = 0
+for b in vim.buffers:
+ # Check buffer order
+ if prevnum >= b.number:
+ cb.append('!!! Buffer numbers not in strictly ascending order')
+ # Check indexing: vim.buffers[number].number == number
+ cb.append(str(b.number) + ':' + repr(vim.buffers[b.number]) + '=' + repr(b))
+ prevnum = b.number
+
+cb.append(str(len(vim.buffers)))
+
+bnums = list(map(lambda b: b.number, vim.buffers))[1:]
+
+# Test wiping out buffer with existing iterator
+i4 = iter(vim.buffers)
+cb.append('i4:' + str(next(i4)))
+vim.command('bwipeout! ' + str(bnums.pop(0)))
+try:
+ next(i4)
+except vim.error:
+ pass
+else:
+ cb.append('!!!! No vim.error')
+i4 = iter(vim.buffers)
+vim.command('bwipeout! ' + str(bnums.pop(-1)))
+vim.command('bwipeout! ' + str(bnums.pop(-1)))
+cb.append('i4:' + str(next(i4)))
+try:
+ next(i4)
+except StopIteration:
+ cb.append('StopIteration')
+EOF
:endfun
:"
:call Test()
: call RecVars(oname)
:endfor
:only
+:for buf in g:bufs[1:]
+: execute 'bwipeout!' buf
+:endfor
:"
:" Test buffer object
:vnew
# Should not happen in any case
cb.append('No exception for ' + expr)
EOF
+:"
+:" Test vim.buffers object
+:set hidden
+:edit a
+:buffer #
+:edit b
+:buffer #
+:edit c
+:buffer #
+py3 << EOF
+# Check GCing iterator that was not fully exhausted
+i = iter(vim.buffers)
+cb.append('i:' + str(next(i)))
+# and also check creating more then one iterator at a time
+i2 = iter(vim.buffers)
+cb.append('i2:' + str(next(i2)))
+cb.append('i:' + str(next(i)))
+# The following should trigger GC and not cause any problems
+del i
+del i2
+i3 = iter(vim.buffers)
+cb.append('i3:' + str(next(i3)))
+del i3
+
+prevnum = 0
+for b in vim.buffers:
+ # Check buffer order
+ if prevnum >= b.number:
+ cb.append('!!! Buffer numbers not in strictly ascending order')
+ # Check indexing: vim.buffers[number].number == number
+ cb.append(str(b.number) + ':' + repr(vim.buffers[b.number]) + '=' + repr(b))
+ prevnum = b.number
+
+cb.append(str(len(vim.buffers)))
+
+bnums = list(map(lambda b: b.number, vim.buffers))[1:]
+
+# Test wiping out buffer with existing iterator
+i4 = iter(vim.buffers)
+cb.append('i4:' + str(next(i4)))
+vim.command('bwipeout! ' + str(bnums.pop(0)))
+try:
+ next(i4)
+except vim.error:
+ pass
+else:
+ cb.append('!!!! No vim.error')
+i4 = iter(vim.buffers)
+vim.command('bwipeout! ' + str(bnums.pop(-1)))
+vim.command('bwipeout! ' + str(bnums.pop(-1)))
+cb.append('i4:' + str(next(i4)))
+try:
+ next(i4)
+except StopIteration:
+ cb.append('StopIteration')
+EOF
:endfun
:"
:call Test()
:call garbagecollect(1)
:"
:/^start:/,$wq! test.out
+:call getchar()
ENDTEST
start:
projects / vim / commitdiff