diff --git a/7.3.949 b/7.3.949
new file mode 100644
index 0000000..419913a
--- /dev/null
+++ b/7.3.949
@@ -0,0 +1,919 @@
+To: vim_dev@googlegroups.com
+Subject: Patch 7.3.949
+Fcc: outbox
+From: Bram Moolenaar <Bram@moolenaar.net>
+Mime-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+------------
+
+Patch 7.3.949
+Problem: Python: no easy access to tabpages.
+Solution: Add vim.tabpages and vim.current.tabpage. (ZyX)
+Files: runtime/doc/if_pyth.txt, src/if_py_both.h, src/if_python3.c,
+ src/if_python.c, src/proto/if_python3.pro,
+ src/proto/if_python.pro, src/proto/window.pro, src/structs.h,
+ src/window.c
+
+
+*** ../vim-7.3.948/runtime/doc/if_pyth.txt 2013-05-15 14:39:47.000000000 +0200
+--- runtime/doc/if_pyth.txt 2013-05-15 15:05:04.000000000 +0200
+***************
+*** 223,228 ****
+--- 223,242 ----
+ :py w in vim.windows # Membership test
+ :py n = len(vim.windows) # Number of elements
+ :py for w in vim.windows: # Sequential access
++ < Note: vim.windows object always accesses current tab page,.
++ |python-tabpage|.windows objects are bound to parent |python-tabpage|
++ object and always use windows from that tab page (or throw vim.error
++ in case tab page was deleted). You can keep a reference to both
++ without keeping a reference to vim module object or |python-tabpage|,
++ they will not loose their properties in this case.
++
++ vim.tabpages *python-tabpages*
++ A sequence object providing access to the list of vim tab pages. The
++ object supports the following operations: >
++ :py t = vim.tabpages[i] # Indexing (read-only)
++ :py t in vim.tabpages # Membership test
++ :py n = len(vim.tabpages) # Number of elements
++ :py for t in vim.tabpages: # Sequential access
+ <
+ vim.current *python-current*
+ An object providing access (via specific attributes) to various
+***************
+*** 230,235 ****
+--- 244,250 ----
+ vim.current.line The current line (RW) String
+ vim.current.buffer The current buffer (RO) Buffer
+ vim.current.window The current window (RO) Window
++ vim.current.tabpage The current tab page (RO) TabPage
+ vim.current.range The current line range (RO) Range
+
+ The last case deserves a little explanation. When the :python or
+***************
+*** 375,380 ****
+--- 390,397 ----
+ Window objects represent vim windows. You can obtain them in a number of ways:
+ - via vim.current.window (|python-current|)
+ - from indexing vim.windows (|python-windows|)
++ - from indexing "windows" attribute of a tab page (|python-tabpage|)
++ - from the "window" attribute of a tab page (|python-tabpage|)
+
+ You can manipulate window objects only through their attributes. They have no
+ methods, and no sequence or other interface.
+***************
+*** 407,412 ****
+--- 424,447 ----
+ The width attribute is writable only if the screen is split vertically.
+
+ ==============================================================================
++ 6. Tab page objects *python-tabpage*
++
++ Tab page objects represent vim tab pages. You can obtain them in a number of
++ ways:
++ - via vim.current.tabpage (|python-current|)
++ - from indexing vim.tabpages (|python-tabpages|)
++
++ You can use this object to access tab page windows. They have no methods and
++ no sequence or other interfaces.
++
++ Tab page attributes are:
++ number The tab page number like the one returned by
++ |tabpagenr()|.
++ windows Like |python-windows|, but for current tab page.
++ vars The tab page |t:| variables.
++ window Current tabpage window.
++
++ ==============================================================================
+ 6. pyeval() and py3eval() Vim functions *python-pyeval*
+
+ To facilitate bi-directional interface, you can use |pyeval()| and |py3eval()|
+*** ../vim-7.3.948/src/if_py_both.h 2013-05-15 14:51:31.000000000 +0200
+--- src/if_py_both.h 2013-05-15 15:10:16.000000000 +0200
+***************
+*** 27,32 ****
+--- 27,33 ----
+
+ #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 *);
+***************
+*** 1579,1584 ****
+--- 1580,1734 ----
+ (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
+ */
+
+***************
+*** 1588,1595 ****
+ win_T *win;
+ } WindowObject;
+
+- static int WindowSetattr(PyObject *, char *, PyObject *);
+- static PyObject *WindowRepr(PyObject *);
+ static PyTypeObject WindowType;
+
+ static int
+--- 1738,1743 ----
+***************
+*** 1681,1687 ****
+ 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));
+ else if (strcmp(name,"__members__") == 0)
+ return Py_BuildValue("[ssssssss]", "buffer", "cursor", "height", "vars",
+ "options", "number", "row", "col");
+--- 1829,1835 ----
+ 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");
+***************
+*** 1797,1803 ****
+ }
+ else
+ {
+! int w = get_win_number(this->win);
+
+ if (w == 0)
+ vim_snprintf(repr, 100, _("<window object (unknown) at %p>"),
+--- 1945,1951 ----
+ }
+ else
+ {
+! int w = get_win_number(this->win, firstwin);
+
+ if (w == 0)
+ vim_snprintf(repr, 100, _("<window object (unknown) at %p>"),
+***************
+*** 1824,1837 ****
+ typedef struct
+ {
+ PyObject_HEAD
+ } WinListObject;
+
+ static PyInt
+! WinListLength(PyObject *self UNUSED)
+ {
+! win_T *w = firstwin;
+ PyInt n = 0;
+
+ while (w != NULL)
+ {
+ ++n;
+--- 1972,2030 ----
+ 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;
+***************
+*** 1842,1852 ****
+ }
+
+ static PyObject *
+! WinListItem(PyObject *self UNUSED, PyInt n)
+ {
+ win_T *w;
+
+! for (w = firstwin; w != NULL; w = W_NEXT(w), --n)
+ if (n == 0)
+ return WindowNew(w);
+
+--- 2035,2048 ----
+ }
+
+ 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);
+
+***************
+*** 3018,3029 ****
+ return (PyObject *)BufferNew(curbuf);
+ else if (strcmp(name, "window") == 0)
+ return (PyObject *)WindowNew(curwin);
+ 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("[ssss]", "buffer", "window", "line", "range");
+ else
+ {
+ PyErr_SetString(PyExc_AttributeError, name);
+--- 3214,3228 ----
+ 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);
+***************
+*** 3568,3573 ****
+--- 3767,3789 ----
+ 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);
+***************
+*** 3582,3587 ****
+--- 3798,3811 ----
+ 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";
+*** ../vim-7.3.948/src/if_python3.c 2013-05-15 14:51:31.000000000 +0200
+--- src/if_python3.c 2013-05-15 15:05:04.000000000 +0200
+***************
+*** 626,631 ****
+--- 626,632 ----
+
+ #define WIN_PYTHON_REF(win) win->w_python3_ref
+ #define BUF_PYTHON_REF(buf) buf->b_python3_ref
++ #define TAB_PYTHON_REF(tab) tab->tp_python3_ref
+
+ static void
+ call_PyObject_Free(void *p)
+***************
+*** 652,657 ****
+--- 653,659 ----
+ static PyObject *OutputGetattro(PyObject *, PyObject *);
+ static int OutputSetattro(PyObject *, PyObject *, PyObject *);
+ static PyObject *BufferGetattro(PyObject *, PyObject *);
++ static PyObject *TabPageGetattro(PyObject *, PyObject *);
+ static PyObject *WindowGetattro(PyObject *, PyObject *);
+ static int WindowSetattro(PyObject *, PyObject *, PyObject *);
+ static PyObject *RangeGetattro(PyObject *, PyObject *);
+***************
+*** 1275,1280 ****
+--- 1277,1302 ----
+ }
+ }
+
++ /* TabPage object - Implementation
++ */
++
++ static PyObject *
++ TabPageGetattro(PyObject *self, PyObject *nameobj)
++ {
++ PyObject *r;
++
++ GET_ATTR_STRING(name, nameobj);
++
++ if (CheckTabPage((TabPageObject *)(self)))
++ return NULL;
++
++ r = TabPageAttr((TabPageObject *)(self), name);
++ if (r || PyErr_Occurred())
++ return r;
++ else
++ return PyObject_GenericGetAttr(self, nameobj);
++ }
++
+ /* Window object - Implementation
+ */
+
+***************
+*** 1303,1308 ****
+--- 1325,1346 ----
+ return WindowSetattr(self, name, val);
+ }
+
++ /* Tab page list object - Definitions
++ */
++
++ static PySequenceMethods TabListAsSeq = {
++ (lenfunc) TabListLength, /* sq_length, len(x) */
++ (binaryfunc) 0, /* sq_concat, x+y */
++ (ssizeargfunc) 0, /* sq_repeat, x*n */
++ (ssizeargfunc) TabListItem, /* sq_item, x[i] */
++ 0, /* sq_slice, x[i:j] */
++ (ssizeobjargproc)0, /* sq_as_item, x[i]=v */
++ 0, /* sq_ass_slice, x[i:j]=v */
++ 0, /* sq_contains */
++ 0, /* sq_inplace_concat */
++ 0, /* sq_inplace_repeat */
++ };
++
+ /* Window list object - Definitions
+ */
+
+***************
+*** 1497,1502 ****
+--- 1535,1551 ----
+ WIN_PYTHON_REF(win) = NULL;
+ }
+ }
++
++ void
++ python3_tabpage_free(tabpage_T *tab)
++ {
++ if (TAB_PYTHON_REF(tab) != NULL)
++ {
++ TabPageObject *tp = TAB_PYTHON_REF(tab);
++ tp->tab = INVALID_TABPAGE_VALUE;
++ TAB_PYTHON_REF(tab) = NULL;
++ }
++ }
+ #endif
+
+ static BufMapObject TheBufferMap =
+***************
+*** 1507,1512 ****
+--- 1556,1562 ----
+ static WinListObject TheWindowList =
+ {
+ PyObject_HEAD_INIT(&WinListType)
++ NULL
+ };
+
+ static CurrentObject TheCurrent =
+***************
+*** 1514,1519 ****
+--- 1564,1574 ----
+ PyObject_HEAD_INIT(&CurrentType)
+ };
+
++ static TabListObject TheTabPageList =
++ {
++ PyObject_HEAD_INIT(&TabListType)
++ };
++
+ static PyObject *
+ Py3Init_vim(void)
+ {
+***************
+*** 1526,1533 ****
+--- 1581,1590 ----
+ PyType_Ready(&BufferType);
+ PyType_Ready(&RangeType);
+ PyType_Ready(&WindowType);
++ PyType_Ready(&TabPageType);
+ PyType_Ready(&BufMapType);
+ PyType_Ready(&WinListType);
++ PyType_Ready(&TabListType);
+ PyType_Ready(&CurrentType);
+ PyType_Ready(&DictionaryType);
+ PyType_Ready(&ListType);
+***************
+*** 1551,1556 ****
+--- 1608,1615 ----
+ PyModule_AddObject(mod, "current", (PyObject *)(void *)&TheCurrent);
+ Py_INCREF((PyObject *)(void *)&TheWindowList);
+ PyModule_AddObject(mod, "windows", (PyObject *)(void *)&TheWindowList);
++ Py_INCREF((PyObject *)(void *)&TheTabPageList);
++ PyModule_AddObject(mod, "tabpages", (PyObject *)(void *)&TheTabPageList);
+
+ PyModule_AddObject(mod, "vars", DictionaryNew(&globvardict));
+ PyModule_AddObject(mod, "vvars", DictionaryNew(&vimvardict));
+*** ../vim-7.3.948/src/if_python.c 2013-05-15 14:51:31.000000000 +0200
+--- src/if_python.c 2013-05-15 15:05:04.000000000 +0200
+***************
+*** 624,633 ****
+--- 624,635 ----
+
+ #define WIN_PYTHON_REF(win) win->w_python_ref
+ #define BUF_PYTHON_REF(buf) buf->b_python_ref
++ #define TAB_PYTHON_REF(tab) tab->tp_python_ref
+
+ static PyObject *OutputGetattr(PyObject *, char *);
+ static PyObject *BufferGetattr(PyObject *, char *);
+ static PyObject *WindowGetattr(PyObject *, char *);
++ static PyObject *TabPageGetattr(PyObject *, char *);
+ static PyObject *RangeGetattr(PyObject *, char *);
+ static PyObject *DictionaryGetattr(PyObject *, char*);
+ static PyObject *ListGetattr(PyObject *, char *);
+***************
+*** 1137,1142 ****
+--- 1139,1162 ----
+ &((RangeObject *)(self))->end);
+ }
+
++ /* TabPage object - Implementation
++ */
++
++ static PyObject *
++ TabPageGetattr(PyObject *self, char *name)
++ {
++ PyObject *r;
++
++ if (CheckTabPage((TabPageObject *)(self)))
++ return NULL;
++
++ r = TabPageAttr((TabPageObject *)(self), name);
++ if (r || PyErr_Occurred())
++ return r;
++ else
++ return Py_FindMethod(TabPageMethods, self, name);
++ }
++
+ /* Window object - Implementation
+ */
+
+***************
+*** 1155,1160 ****
+--- 1175,1198 ----
+ return Py_FindMethod(WindowMethods, self, name);
+ }
+
++ /* Tab page list object - Definitions
++ */
++
++ static PySequenceMethods TabListAsSeq = {
++ (PyInquiry) TabListLength, /* sq_length, len(x) */
++ (binaryfunc) 0, /* sq_concat, x+y */
++ (PyIntArgFunc) 0, /* sq_repeat, x*n */
++ (PyIntArgFunc) TabListItem, /* sq_item, x[i] */
++ (PyIntIntArgFunc) 0, /* sq_slice, x[i:j] */
++ (PyIntObjArgProc) 0, /* sq_ass_item, x[i]=v */
++ (PyIntIntObjArgProc) 0, /* sq_ass_slice, x[i:j]=v */
++ (objobjproc) 0,
++ #if PY_MAJOR_VERSION >= 2
++ (binaryfunc) 0,
++ 0,
++ #endif
++ };
++
+ /* Window list object - Definitions
+ */
+
+***************
+*** 1198,1203 ****
+--- 1236,1252 ----
+ WIN_PYTHON_REF(win) = NULL;
+ }
+ }
++
++ void
++ python_tabpage_free(tabpage_T *tab)
++ {
++ if (TAB_PYTHON_REF(tab) != NULL)
++ {
++ TabPageObject *tp = TAB_PYTHON_REF(tab);
++ tp->tab = INVALID_TABPAGE_VALUE;
++ TAB_PYTHON_REF(tab) = NULL;
++ }
++ }
+ #endif
+
+ static BufMapObject TheBufferMap =
+***************
+*** 1208,1213 ****
+--- 1257,1263 ----
+ static WinListObject TheWindowList =
+ {
+ PyObject_HEAD_INIT(&WinListType)
++ NULL
+ };
+
+ static CurrentObject TheCurrent =
+***************
+*** 1215,1220 ****
+--- 1265,1275 ----
+ PyObject_HEAD_INIT(&CurrentType)
+ };
+
++ static TabListObject TheTabPageList =
++ {
++ PyObject_HEAD_INIT(&TabListType)
++ };
++
+ static int
+ PythonMod_Init(void)
+ {
+***************
+*** 1229,1236 ****
+--- 1284,1293 ----
+ PyType_Ready(&BufferType);
+ PyType_Ready(&RangeType);
+ PyType_Ready(&WindowType);
++ PyType_Ready(&TabPageType);
+ PyType_Ready(&BufMapType);
+ PyType_Ready(&WinListType);
++ PyType_Ready(&TabListType);
+ PyType_Ready(&CurrentType);
+ PyType_Ready(&OptionsType);
+
+***************
+*** 1246,1251 ****
+--- 1303,1309 ----
+ PyDict_SetItemString(dict, "buffers", (PyObject *)(void *)&TheBufferMap);
+ PyDict_SetItemString(dict, "current", (PyObject *)(void *)&TheCurrent);
+ PyDict_SetItemString(dict, "windows", (PyObject *)(void *)&TheWindowList);
++ PyDict_SetItemString(dict, "tabpages", (PyObject *)(void *)&TheTabPageList);
+ tmp = DictionaryNew(&globvardict);
+ PyDict_SetItemString(dict, "vars", tmp);
+ Py_DECREF(tmp);
+*** ../vim-7.3.948/src/proto/if_python3.pro 2012-06-29 12:54:32.000000000 +0200
+--- src/proto/if_python3.pro 2013-05-15 15:05:04.000000000 +0200
+***************
+*** 6,11 ****
+--- 6,12 ----
+ void ex_py3file __ARGS((exarg_T *eap));
+ void python3_buffer_free __ARGS((buf_T *buf));
+ void python3_window_free __ARGS((win_T *win));
++ void python3_tabpage_free __ARGS((tabpage_T *tab));
+ void do_py3eval __ARGS((char_u *str, typval_T *rettv));
+ void set_ref_in_python3 __ARGS((int copyID));
+ /* vim: set ft=c : */
+*** ../vim-7.3.948/src/proto/if_python.pro 2012-06-29 12:54:32.000000000 +0200
+--- src/proto/if_python.pro 2013-05-15 15:05:04.000000000 +0200
+***************
+*** 6,11 ****
+--- 6,12 ----
+ void ex_pyfile __ARGS((exarg_T *eap));
+ void python_buffer_free __ARGS((buf_T *buf));
+ void python_window_free __ARGS((win_T *win));
++ void python_tabpage_free __ARGS((tabpage_T *tab));
+ void do_pyeval __ARGS((char_u *str, typval_T *rettv));
+ void set_ref_in_python __ARGS((int copyID));
+ /* vim: set ft=c : */
+*** ../vim-7.3.948/src/proto/window.pro 2013-05-12 19:00:36.000000000 +0200
+--- src/proto/window.pro 2013-05-15 15:05:04.000000000 +0200
+***************
+*** 74,78 ****
+ int match_delete __ARGS((win_T *wp, int id, int perr));
+ void clear_matches __ARGS((win_T *wp));
+ matchitem_T *get_match __ARGS((win_T *wp, int id));
+! int get_win_number __ARGS((win_T *wp));
+ /* vim: set ft=c : */
+--- 74,79 ----
+ int match_delete __ARGS((win_T *wp, int id, int perr));
+ void clear_matches __ARGS((win_T *wp));
+ matchitem_T *get_match __ARGS((win_T *wp, int id));
+! int get_win_number __ARGS((win_T *wp, win_T *first_win));
+! int get_tab_number __ARGS((tabpage_T *tp));
+ /* vim: set ft=c : */
+*** ../vim-7.3.948/src/structs.h 2013-05-06 04:21:35.000000000 +0200
+--- src/structs.h 2013-05-15 15:05:04.000000000 +0200
+***************
+*** 1759,1764 ****
+--- 1759,1772 ----
+ dictitem_T tp_winvar; /* variable for "t:" Dictionary */
+ dict_T *tp_vars; /* internal variables, local to tab page */
+ #endif
++
++ #ifdef FEAT_PYTHON
++ void *tp_python_ref; /* The Python value for this tab page */
++ #endif
++
++ #ifdef FEAT_PYTHON3
++ void *tp_python3_ref; /* The Python value for this tab page */
++ #endif
+ };
+
+ /*
+*** ../vim-7.3.948/src/window.c 2013-05-12 19:00:36.000000000 +0200
+--- src/window.c 2013-05-15 15:05:04.000000000 +0200
+***************
+*** 3510,3515 ****
+--- 3510,3524 ----
+ hash_init(&tp->tp_vars->dv_hashtab);
+ unref_var_dict(tp->tp_vars);
+ #endif
++
++ #ifdef FEAT_PYTHON
++ python_tabpage_free(tp);
++ #endif
++
++ #ifdef FEAT_PYTHON3
++ python3_tabpage_free(tp);
++ #endif
++
+ vim_free(tp);
+ }
+
+***************
+*** 6734,6750 ****
+
+ #if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3) || defined(PROTO)
+ int
+! get_win_number(win_T *wp)
+ {
+ int i = 1;
+ win_T *w;
+
+! for (w = firstwin; w != NULL && w != wp; w = W_NEXT(w))
+ ++i;
+
+ if (w == NULL)
+ return 0;
+ else
+ return i;
+ }
+ #endif
+--- 6743,6774 ----
+
+ #if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3) || defined(PROTO)
+ int
+! get_win_number(win_T *wp, win_T *first_win)
+ {
+ int i = 1;
+ win_T *w;
+
+! for (w = first_win; w != NULL && w != wp; w = W_NEXT(w))
+ ++i;
+
+ if (w == NULL)
+ return 0;
+ else
+ return i;
++ }
++
++ int
++ get_tab_number(tabpage_T *tp)
++ {
++ int i = 1;
++ tabpage_T *t;
++
++ for (t = first_tabpage; t != NULL && t != tp; t = t->tp_next)
++ ++i;
++
++ if (t == NULL)
++ return 0;
++ else
++ return i;
+ }
+ #endif
+*** ../vim-7.3.948/src/version.c 2013-05-15 14:51:31.000000000 +0200
+--- src/version.c 2013-05-15 15:06:37.000000000 +0200
+***************
+*** 730,731 ****
+--- 730,733 ----
+ { /* Add new patch number below this line */
++ /**/
++ 949,
+ /**/
+
+--
+BLACK KNIGHT: Come on you pansy!
+ [hah] [parry thrust]
+ [ARTHUR chops the BLACK KNIGHT's right arm off]
+ARTHUR: Victory is mine! [kneeling]
+ We thank thee Lord, that in thy merc-
+ [Black Knight kicks Arthur in the head while he is praying]
+ The Quest for the Holy Grail (Monty Python)
+
+ /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net \\\
+/// sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
+\\\ an exciting new programming language -- http://www.Zimbu.org ///
+ \\\ help me help AIDS victims -- http://ICCF-Holland.org ///